player.cpp

2002年

void Player::set_side(bool Is_myside){
	if (Is_myside){
		side = Side_My;
	}
	else{
		side = Side_Opp;
	}
}

void Player::set_side(PlayerSide side){
	this->side = side;
}

void Player::ChangeType(int type){
	CopyType(type);
	max_speed = player_speed_max;
	speed_decay = player_decay;
}

void Player::Set_Iscontrolball_Fromheard(Time time){
	if(heard_iscontrolball.time == time){
		Iscontrolball = heard_iscontrolball.data; 
	}
}

bool Player::IsStrained(){
	return bool(stamina < 0.5f * ServerParam::stamina_max);
}

bool Player::IsExtremStrained(){
	return bool(stamina < ServerParam::stamina_max * ServerParam::recover_dec_thr);
}

bool Player::IsUniformNo(UNum No){
	return No >0 && No <= 2*SP_team_size;
}

bool Player::IsValidNo(UNum No){
	return No > 0 && No <= 7 * SP_team_size;
}

bool Player::IsMyPlayer(UNum No){
	if (No <= 0) return false;
	int seg = (No -1 ) / SP_team_size;
	int rem = (No -1)  % SP_team_size;
	switch(seg){
	case 0:
		return true;
	case 2:
	case 3:
		return UnknownMyPlayerList.IsIdxValid(rem);
//	case 6:
//		return TeamlessPlayerList.IsIdxValid(rem);
		
	}
	return false;
}

bool Player::IsTheirPlayer(UNum No){
	if (No <= 0) return false;
	int seg = (No -1 ) / SP_team_size;
	int rem = (No -1)  % SP_team_size;
	switch(seg){
	case 0:
		return false;
	case 1:
		return true;
	case 4:
	case 5:
		return UnknownTheirPlayerList.IsIdxValid(rem);
	case 6:
		return TeamlessPlayerList.IsIdxValid(rem);		
	}
	return false;
}

bool Player::IsUnknownPlayer(UNum No){
	return bool(No <= 0 || No > 2 * SP_team_size);
}



/**************************   Self   *********************************/
MySelf::MySelf(){
	pos_delta = 0;
	pos_conf = 1.0f;
	bodyfc_guessed = false;
	pos_delta_valid = true;
	updated_sight_time = -1; 
}

void MySelf::update(Time time){
/*********	time is assumed to be CurrentTime here	********/
	if (sensory.SensedInfKnown(time)){
		update_from_senseinfo(sensory.GetSenseBodyInfo(time));
	}else{
		estimate_headangle(time);
		estimate_stamina(time);
		estimate_effort(time);
	}

	update_seen_facing(time);
	estimate_facing(time);

	update_vel(time);// vel should be updated before pos
	update_seen_pos(time);
	estimate_pos(time);

	pos = Pos(time);
	global_vel = Vel(time);
	speed = global_vel.mod();
	vel_angle = global_vel.Angle();
	bodyfacing = Bodyfacing(time);
	headfacing = Headfacing(time);
	head_angle = Headangle(time);
	stamina = Stamina(time);
	effort = Effort(time);
	pos_time = time;
	vel_time = time;
	Focus = FocusPlayers.ChkData(time);
}

void MySelf::update_from_senseinfo(SenseBodyInfo & sb){
	viewwidth.Setdata(sb.view_width, sb.time);
	viewqual.Setdata(sb.view_qual, sb.time);
	stmn.Setdata(sb.stamina, sb.time);
	spd.Setdata(sb.speed < max_speed * speed_decay ? sb.speed : max_speed * speed_decay, sb.time);
	spdang.Setdata(sb.rel_spd_angle, sb.time);
	headang.Setdata(sb.head_angle, sb.time);
	efft.Setdata(sb.effort, sb.time);
	FocusPlayers.Setdata(sb.Focus, sb.time);
}

void MySelf::estimate_headangle(Time time){
	if (Skill::action.Valid(CMD_turn_neck)){
		headang.Setdata(Headangle(situation.LastCycle()) + Skill::action.TurnNeckEffect(situation.LastCycle()), time);
	}
}

void MySelf::estimate_stamina(Time time){
	stmn.Setdata(Stamina(situation.LastCycle()) - Skill::action.UsedPower(situation.LastCycle()), time);
}

void MySelf::estimate_effort(Time time){
	efft.Setdata(Effort(situation.LastCycle()), time);
}

void MySelf::update_seen_facing(Time time){
#ifdef	_Up_FState
	if(sensory.HasFullState() && acc_bodyangle.IsDataKnown(time)){
		bodyfc.Setdata(NormalizeAngle(acc_bodyangle.Data(time)), time);
		headfc.Setdata(NormalizeAngle(acc_bodyangle.Data(time)+acc_neckangle.Data(time)), time); 
		return;
	} 
#endif
	if (!sensory.NewSight) return;

/******	update facings from seen	************/
	int last_update_seen_time = Max(update_seen_time, time -2);
	int t;
	for(t = last_update_seen_time + 1; t <= sensory.LastSightTime; t ++){
		if (sensory.num_seenlines.ChkData(t) > 0){
			int line = sensory.SeenLines.Data(0, t);
			float rel_angle_2_line = PitchInfo.Lines[line].seen_rel_angle(t);
			if (rel_angle_2_line < 0){
				rel_angle_2_line += 180.0f;
			}

			headfc.Setdata(NormalizeAngle(PitchInfo.Lines[line].global_angle - rel_angle_2_line), t);
			bodyfc.Setdata(NormalizeAngle(Headfacing(t) - Headangle(t)), t);
		}
		else if (sensory.num_seenmarkers.ChkData(t) >= 2 ){
			//find two markers with known distance
			MarkerType marker1, marker2;
			marker1 = sensory.SeenMarkers.Data(0, t);
			marker2 = sensory.SeenMarkers.Data(1, t);

			PitchInfo.Markers[marker1].rel_pos = Polar2Vector(PitchInfo.Markers[marker1].seen_distance(t), PitchInfo.Markers[marker1].seen_rel_angle(t));
			PitchInfo.Markers[marker2].rel_pos = Polar2Vector(PitchInfo.Markers[marker2].seen_distance(t), PitchInfo.Markers[marker2].seen_rel_angle(t));
			Vector gap1 = PitchInfo.Markers[marker1].rel_pos - PitchInfo.Markers[marker2].rel_pos;
			Vector gap2 = PitchInfo.Markers[marker1].pos - PitchInfo.Markers[marker2].pos;
			headfc.Setdata(NormalizeAngle(gap2.Angle() - gap1.Angle()),	t);
			bodyfc.Setdata(NormalizeAngle(Headfacing(t) - Headangle(t)), t);
		}
	}
}

void MySelf::estimate_facing(Time time){
	if(!IsBodyfacingKnown(time)){
		if (!IsBodyfacingKnown(situation.LastCycle())){
			/********	must miss some cycles	************/
			bodyfc.Setdata(NormalizeAngle(Bodyfacing(pos_time) + Skill::action.SummarizeTurneffect(pos_time, situation.LastCycle()))
				, situation.LastCycle());
			if(IsHeadAngleKnown(situation.LastCycle())){
				headang.Setdata(NormalizeAngle(Headangle(pos_time) + Skill::action.SummarizeTurnneckeffect(pos_time, situation.LastCycle()))
					, situation.LastCycle());
			}
			headfc.Setdata(NormalizeAngle(Bodyfacing(situation.LastCycle()) + Headangle(situation.LastCycle())), 
					situation.LastCycle());
		}

		bodyfc.Setdata(NormalizeAngle(Bodyfacing(situation.LastCycle()) + Skill::action.TurnEffect(situation.LastCycle())), time);
		headfc.Setdata(NormalizeAngle(Bodyfacing(time) + Headangle(time)), time); 
	}
}

void MySelf::update_vel(Time time){
#ifdef	_Up_FState
	if(sensory.HasFullState() && acc_vel.IsDataKnown(time)){
		gvel.Setdata(acc_vel.Data(time), time);
		vel_time = time;
		return;
	} 
#endif

	Vector evel = Skill::action.SummarizeDasheffectVel(Vel(vel_time), vel_time, time, speed_decay, max_speed);

	if (sensory.SensedInfKnown(time)){
		gvel.Setdata(Polar2Vector(Speed(time), SpeedAngle(time) + Headfacing(time)), time);

		float Velgap =(float)fabs(gvel.Data(time).mod() - evel.mod());

		Vector svgap = gvel.Data(time) - evel;

		if(Velgap >ClientParam::selfvel_mingap && Speed(time) <= max_speed * 0.11f * speed_decay){
			DoLog(LOG_COLLIDE,"self coll Velgap%.2f,Vector Gap(%.2f,%.2f)",Velgap,svgap.x,svgap.y);
			selfcoll.Setdata(true,time);
		}else
			selfcoll.Setdata(false,time);
	}else{
		/*estimate vel*/
		gvel.Setdata(evel, time);
	}
	vel_time = time;
}

void MySelf::update_seen_pos(Time time){
#ifdef	_Up_FState
	if(sensory.HasFullState() && acc_vel.IsDataKnown(time)){
		gpos.Setdata(acc_pos.Data(time), time);
		pos_time = time;
		newpos = true;
		update_seen_time = time;
		pos_gap.Setdata(0, time);
		return;
	}
#endif
/********	Update Pos from seen	**************/
	if(!sensory.NewSight) return;

	int last_update_seen_time = Max(update_seen_time, time -2);
	MarkerType closestmarker;
	int t;
	for(t = last_update_seen_time + 1; t <= sensory.LastSightTime; t ++){
		if (sensory.num_seenmarkers.ChkData(t) > 0){
			/***********	calculate pos gap	***************/
 			closestmarker = sensory.GetClosestMarker(t);
			if (closestmarker != No_Marker){
				PitchInfo.Markers[closestmarker].rel_pos = Polar2Vector(PitchInfo.Markers[closestmarker].seen_distance(t),
					Headfacing(t) + PitchInfo.Markers[closestmarker].seen_rel_angle(t));
				gpos.Setdata(PitchInfo.Markers[closestmarker].pos - PitchInfo.Markers[closestmarker].rel_pos, t);
				DoLog(LOG_UPDATE, "Player Pos Updated (%.2f %.2f) at %d", Pos(t).x, Pos(t).y, t);

				if(pos_time < t -1){
					estimate_pos(t-1);
				}
				Vector posbk = Pos(t-1) + Vel(t) / speed_decay;
				pos_gap.Setdata(Pos(t) - posbk, t);
				if(pos_gap.Data(t).mod() > 4.0f){
					DoLog("I'm moved");
					selfmove.Setdata(true, t);
					pos_gap.Setdata(0, t);
				}else if(selfcoll.ChkData(t)){
					pos_gap.Setdata(0, t);
				} 
				DoLog(LOG_UPDATE, "PrevCoord (%.2f %.2f)", posbk.x, posbk.y);				
				pos_time = t;
				newpos = true;
				update_seen_time = t;
			}
		}
	}
}


void MySelf::estimate_pos(Time time){
	if (pos_time < time){
		gpos.Setdata(Pos(pos_time) + SummarizeVelPos(pos_time, time), time);
		pos_time = time;
	}
}

Vector MySelf::SummarizeVelPos(Time prev, Time last){
	Vector moved_pos = 0;
	for(Time time = prev; time < last; time ++){
		moved_pos += Vel(time + 1) / speed_decay;
	}
	return moved_pos;
}

Vector MySelf::SummarizePosGap(Time prev, Time last){
	Vector moved_pos = 0;
	for(Time time = prev + 1; time <= last; time ++){
		moved_pos += pos_gap.ChkData(time);
	}
	return moved_pos;
}

bool MySelf::SelfColl(Time prevtime,Time lastime ){
	for(Time t=prevtime; t<=lastime;t++){
		if(selfcoll.ChkData(t)) return true;
	}
	return false;
}


Vector MySelf::PredictPos(float dash_pow, int cycles){
	Vector predictpos = pos;
	Vector vel = global_vel;
	int i;
	for(i = 0; i < cycles; i ++){
		vel += Polar2Vector(dash_pow, Self.bodyfacing) * Skill::action.Dashrate();
		if (vel.mod() > max_speed){
			vel = vel / vel.mod() * max_speed;
		}
		predictpos += vel;
		vel *= speed_decay;
	}
	return predictpos;
}

Vector MySelf::PredictPos(int cycles){
	return MobileObject::PredictPos(cycles);
}

Vector MySelf::PredictPos(AngleDeg facing, float dash_pow, int cycles){
	Vector predictpos = pos;
	Vector vel = global_vel;
	int i;
	for(i = 0; i < cycles; i ++){
		vel += Polar2Vector(dash_pow, facing) * Skill::action.Dashrate();
		if (vel.mod() > ServerParam::player_speed_max){
			vel = vel / vel.mod() * max_speed;
		}
		predictpos += vel;
		vel *= speed_decay;
	}
	return predictpos;
}

Vector MySelf::PredictPosWithTurnDash(AngleDeg angle, float dash_pow){
	Vector predictpos = Self.PredictPos(2);
	predictpos += Polar2Vector(dash_pow * Skill::action.Dashrate(), angle);
	return predictpos;
}

AngleDeg MySelf::MyViewWidth(VIEWWIDTH view_width){
	switch(view_width){
	case VW_Normal : return 90;
	case VW_Narrow : return 45;
	case VW_Wide   : return 180;
	}
	return 0.0f;
}

AngleDeg MySelf::MyViewAngle(VIEWWIDTH view_width){
	return MyViewWidth(view_width) / 2.0f;
}

AngleDeg MySelf::MyViewWidth(VWTime time){
	VIEWWIDTH VWidth = (time == VWT_Current) ? sensory.ViewWidth : sensory.NextViewWidth;
	return MyViewWidth(VWidth);
}


AngleDeg MySelf::MyViewAngle(VWTime time){
	return MyViewWidth(time) / 2.0f;
}

bool MySelf::Is_Rec_Sight_Info(Time t){
	return sensory.rec_sight_info.ChkData(t);
}