////////////////////////////////////////////////////////////////////////////////
//	قȂʒuɂ2̓_ABԂ̋擾
//	
//	@param Ax	_AxW
//	@param Ay	_AyW
//	@param Bx	_BxW
//	@param By	_ByW
//	@return _ABԂ̋
//	
////////////////////////////////////////////////////////////////////////////////
function GetGapLength(Ax,Ay,Bx,By){
	return ( ( Bx - Ax ) ^ 2 + ( By - Ay ) ^ 2 ) ^ 0.5;
}

////////////////////////////////////////////////////////////////////////////////
//	_AقȂʒuɂ_Bւ̐Ίpx擾
//	
//	@param Ax	_AxW
//	@param Ay	_AyW
//	@param Bx	_BxW
//	@param By	_ByW
//	@return _A_Bւ̐Ίpx
//	
////////////////////////////////////////////////////////////////////////////////
function GetGapAngle(Ax,Ay,Bx,By){
	return atan2( By - Ay, Bx - Ax );
}

////////////////////////////////////////////////////////////////////////////////
//	_A炠鋗AΊpxɂ_BxW擾
//	
//	@param Ax		_AxW
//	@param GapLength	_B܂ł̋
//	@param GapAngle	_Bւ̐Ίpx
//	@return _BxW
//	
////////////////////////////////////////////////////////////////////////////////
function GetGapX(Ax,GapLength,GapAngle){
	return Ax + GapLength * cos(GapAngle);
}

////////////////////////////////////////////////////////////////////////////////
//	_A炠鋗AΊpxɂ_ByW擾
//	
//	@param Ay		_AyW
//	@param GapLength	_B܂ł̋
//	@param GapAngle	_Bւ̐Ίpx
//	@return _ByW
//	
////////////////////////////////////////////////////////////////////////////////
function GetGapY(Ay,GapLength,GapAngle){
	return Ay + GapLength * sin(GapAngle);
}

////////////////////////////////////////////////////////////////////////////////
//	^ꂽpx0ȏ360ɂĕԂ
//	
//	@param Angle	px
//	@return ꂽpx
//	
////////////////////////////////////////////////////////////////////////////////
function RollAngle(Angle){
	return absolute( Angle % 360 );
}

////////////////////////////////////////////////////////////////////////////////
//	px␳z[~O֐
//	
//	@param X	݈ʒuxW
//	@param Y	݈ʒuyW
//	@param ToX	ǔڕWxW
//	@param ToY	ǔڕWyW
//	@param N_Angle	݂̊px
//	@param DAngle	px␳ʍől
//	@return z[~O␳̊px
//	
////////////////////////////////////////////////////////////////////////////////
function AngleSearch(X,Y,ToX,ToY,N_Angle,DAngle){
	let TargetAngle = atan2(ToY - Y,ToX - X);
	let ICross = cos(N_Angle - TargetAngle);
	let CCross = cos(DAngle);
	
	if(ICross < CCross){
		let LCross = cos(N_Angle - DAngle - TargetAngle);
		let RCross = cos(N_Angle + DAngle - TargetAngle);
		if(LCross > RCross){
			N_Angle -= DAngle;
		}else{
			N_Angle += DAngle;
		}
	}else{
		N_Angle = TargetAngle;
	}
	
	return N_Angle;
}

////////////////////////////////////////////////////////////////////////////////
//	3DW2DWɕϊ
//	
//	@param x	xW
//	@param y	yW
//	@param z	zW
//	@param a	x̉]px
//	@param b	ỷ]px
//	@param c	z̉]px
//	@return xW,yW,zW̔z[x,y,z]
//	
////////////////////////////////////////////////////////////////////////////////
function Conv3Dto2D(x,y,z,a,b,c){
	let xyz = [x,y,z];
	
	xyz = RollZ(xyz[0],xyz[1],xyz[2],c);
	xyz = RollX(xyz[0],xyz[1],xyz[2],a);
	xyz = RollY(xyz[0],xyz[1],xyz[2],b);
	
	return xyz;
}

function RollX(x,y,z,a){
	let xx = x;
	let yy = y * cos(a) - z * sin(a);
	let zz = y * sin(a) + z * cos(a);
	
	return [xx,yy,zz];
}

function RollY(x,y,z,a){
	let xx = z * sin(a) + x * cos(a);
	let yy = y;
	let zz = z * cos(a) - x * sin(a);
	
	return [xx,yy,zz];
}

function RollZ(x,y,z,a){
	let xx = x * cos(a) - y * sin(a);
	let yy = x * sin(a) + y * cos(a);
	let zz = z;
	
	return [xx,yy,zz];
}

////////////////////////////////////////////////////////////////////////////////
//	_(x,y)pxangleňƕǂƂ̌_AˊpԂ
//	
//	@param x w_xW
//	@param y w_yW
//	@param angle px
//	@return ǂƂ̌_Aˊp[rx,ry,rangle]
//	
////////////////////////////////////////////////////////////////////////////////
function GetReflectData(let x,let y,let angle){
	let rx = 0;
	let ry = 0;
	let rangle = 0;
	
	// ɂ邽߂̏I_ݒ
	let tox = x + cos(angle) * 800;	// Kɑ傫lŏI_쐬
	let toy = y + sin(angle) * 800;	// Kɑ傫lŏI_쐬
	
	// ȗ̂߁Bl̕ϐ錾Ăꍇɂ͏ĂOK
	let MinX = GetClipMinX();
	let MaxX = GetClipMaxX();
	let MinY = GetClipMinY();
	let MaxY = GetClipMaxY();
	
	// ㉺Eɑ΂Ĕs
	let PosU = Collision_Line_Line(x,y,tox,toy,MinX,MinY,MaxX,MinY);
	let PosL = Collision_Line_Line(x,y,tox,toy,MinX,MinY,MinX,MaxY);
	let PosR = Collision_Line_Line(x,y,tox,toy,MaxX,MinY,MaxX,MaxY);
	let PosB = Collision_Line_Line(x,y,tox,toy,MinX,MaxY,MaxX,MaxY);
	
	// ʂɂĂǂ̕ǂŔ˂邩I ㉺ȄŔ肳܂
	if( PosU[0] != NULL ){
		// ゾ
		rx = PosU[0];
		ry = PosU[1];
		rangle = -angle;
	}else if( PosB[0] != NULL ){
		// 
		rx = PosB[0];
		ry = PosB[1];
		rangle = -angle;
	}else if( PosL[0] != NULL ){
		// 
		rx = PosL[0];
		ry = PosL[1];
		rangle = 180 - angle;
	}else if( PosR[0] != NULL ){
		// E
		rx = PosR[0];
		ry = PosR[1];
		rangle = 180 - angle;
	}else{
		// ǂɂ˂ĂȂꍇA_~[ƂČ̒lZbg
		rx = x;
		ry = y;
		rangle = angle;
	}
	
	return [rx,ry,rangle];
}

////////////////////////////////////////////////////////////////////////////////
//	(x1,y1)-(x2,y2)Ɛ(x3,y3)-(x4,y4)̌_Ԃ
//	
//	@param x1 1̎n_xW
//	@param y1 1̎n_yW
//	@param x2 1̏I_xW
//	@param y2 1̏I_yW
//	@param x3 2̎n_xW
//	@param y3 2̎n_yW
//	@param x4 2̏I_xW
//	@param y4 2̏I_yW
//	@return 2̌_[x,y] Ȃꍇɂ[NULL,NULL]Ԃ
//	
////////////////////////////////////////////////////////////////////////////////
function Collision_Line_Line(let x1,let y1,let x2,let y2,let x3,let y3,let x4,let y4){
	let f1 = x2 - x1;
	let g1 = y2 - y1;
	let f2 = x4 - x3;
	let g2 = y4 - y3;
	
	let det = (f2 * g1) - (f1 * g2);
	
	// det̒l0(2)̏ꍇ_݂Ȃ̂Ŗ߂
	if(det == 0){
		return [NULL,NULL];
	}else{
		// ȊȌꍇA_vZ
		let dx = x3 - x1;
		let dy = y3 - y1;
		let t1 = (f2 * dy - g2 * dx) / det;
		let t2 = (f1 * dy - g1 * dx) / det;
		
		// _̒ɑ݂Ȃ琔lvZ
		if( (0 <= t1 && t1 <= 1) && (0 <= t2 && t2 <= 1) ){
			let rx = x1 + t1 * f1;
			let ry = y1 + t1 * g1;
			
			return [rx,ry];
		}else{
			// _̉ɂꍇA_ȂƂ
			return [NULL,NULL];
		}
	}
}