tac_class.cpp

空战游戏flacon源码

		if (*ptr == '\\')
		{
			dst = te_filename;
			src = NULL;
		}

		ptr ++;
	}

	*dst = '\0';

	if (src)
	{
		*src ++ = 't';
		*src ++ = 'e';
		*src ++ = '\0';
	}
	
	if ((stricmp (ext, "tac") == 0) || (stricmp (ext, "trn") == 0))
	{
		//MonoPrint ("Extracting TE File from %s\n", filename);

		fp = fopen (filename, "rb");

		if (fp)
		{
			fread (&offset, 4, 1, fp);

			fseek (fp, offset, 0);

			fread (&num_files, 4, 1, fp);

			while (num_files)
			{
				fread (&str_len, 1, 1, fp);
				str_len &= 0xff;

				fread (name, str_len, 1, fp);\
				name[str_len] = '\0';

				if (string_compare_extensions (name, te_filename) == 0)
				{
					fread (&offset, 4, 1, fp);
					fread (size, 4, 1, fp);

					fseek (fp, offset, 0);

					ptr = new char[*size];

					fread (ptr, *size, 1, fp);

					fclose (fp);

					return ptr;
				}
				else
				{
					fseek (fp, 8, 1); // seek relative
				}

				num_files --;
			}
		}

		return NULL;
	}
	else
	{
		fp = fopen (filename, "rb");

		if (fp)
		{
			fseek (fp, 0, 2); // seek end

			*size = ftell (fp);

			fseek (fp, 0, 0); // seek start

			ptr = new char[*size];

			fread (ptr, *size, 1, fp);

			fclose (fp);

			return ptr;
		}

		return NULL;
	}
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

void tactical_mission::info_load (char *the_filename)
{
	int
		size;

	char
		*data;

	if (strcmp (filename, the_filename) != 0)
	{
		delete (filename);

		filename = new char[strlen (the_filename)];

		strcpy (filename, the_filename);
	}

	data = read_te_file (filename, &size);

	if (!data)
	{
		MonoPrint ("Cannot open a file we just decided existed\n");

		return;
	}

	process_load (data, size, FALSE);

	delete data;
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

void tactical_mission::load (void)
{
	int
		size;

	char
		*ptr,
		*ext,
		*data,
		*name;

	if (!is_online)
	{
		data = read_te_file (filename, &size);

		//MonoPrint ("Tactical_Mission::Load %s\n", filename);

		if (!data)
		{
			MonoPrint ("Cannot open a file we just decided existed\n");

			return;
		}

		name = filename;
		
		ptr = filename;

		while (*ptr)
		{
			if (*ptr == '\\')
			{
				name = &ptr[1];
			}
			ptr ++;
		}

		ptr = gUI_CampaignFile;

		ext = NULL;
		while (*name)
		{
			if (*name == '.')
			{
				ext = ptr;
			}

			*ptr = *name;

			name ++;
			ptr ++;
		}

		*ptr = '\0';
		if(ext)
			*ext = '\0';

		ShowGameOverWindow=0;

		_tcscpy(gUI_ScenarioName,get_title());

		FalconLocalSession->SetCountry(static_cast<uchar>(gSelectedTeam));

		SendMessage(FalconDisplay.appWin, FM_LOAD_CAMPAIGN, 0, game_TacticalEngagement);

/*		victory_condition::enter_critical_section ();

		while (conditions)
		{
			delete conditions;
		}

		conditions = NULL;

		victory_condition::leave_critical_section ();

		process_load (data, size, TRUE);
*/
		delete data;
	}
	else
	{
		FalconLocalSession->SetCountry(gSelectedTeam);
		StartCampaignGame (0, game_TacticalEngagement);
	}
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

void tactical_mission::preload (void)
{
	char
		*ext,
		*ptr,
		*name;

	if (this)
	{
		name = filename;
		
		ptr = filename;

		while (*ptr)
		{
			if (*ptr == '\\')
			{
				name = &ptr[1];
			}
			ptr ++;
		}

		ptr = gUI_CampaignFile;

		ext = ptr;

		while (*name)
		{
			if (*name == '.')
			{
				ext = ptr;
			}

			*ptr = *name;

			name ++;
			ptr ++;
		}

		*ext = '\0';
		*ptr = '\0';

		_tcscpy(gUI_ScenarioName,get_title());
	}
	else
	{
		strcpy (gUI_CampaignFile, "te_new");
		_tcscpy(gUI_ScenarioName, "te_new");
	}

	TheCampaign.Suspend ();

	TheCampaign.LoadScenarioStats (game_TacticalEngagement, gUI_CampaignFile);

//	StartReadCampFile (game_TacticalEngagement, gUI_CampaignFile);
//
//	if (!LoadTeams (gUI_CampaignFile))
//	{
//		AddNewTeams (Neutral);
//	}
//
//	EndReadCampFile ();
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

void tactical_mission::new_setup (void)
{
	//MonoPrint ("Tactical_Mission::New Setup\n");

	strcpy (gUI_CampaignFile, "te_new");

	is_new = TRUE;

	_tcscpy(gUI_ScenarioName,get_title());

//	FalconLocalSession->SetCountry (team);

	SendMessage (gMainHandler->GetAppWnd (), FM_LOAD_CAMPAIGN, 0, game_TacticalEngagement);

	//MonoPrint ("Tactical_Mission::New Setup\n");
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

void tactical_mission::revert (void)
{
	//MonoPrint ("Tactical_Mission::Revert %s\n", filename);

	// HACK - Robin (unnessary hack)
	//FalconLocalSession->SetCountry(gSelectedTeam);
	SendMessage(gMainHandler->GetAppWnd (), FM_LOAD_CAMPAIGN, 0, game_TacticalEngagement);
}

//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

int tactical_mission::get_number_of_teams (void)
{
	return number_teams;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

int tactical_mission::get_number_of_aircraft (int team)
{
	return number_aircraft[team];
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

int tactical_mission::get_number_of_players (int team)
{
	return number_players[team];
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

int tactical_mission::get_number_of_f16s (int team)
{
	return number_f16s[team];
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

char *tactical_mission::get_team_name (int team)
{
	return team_name[team];
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

void tactical_mission::set_team_name (int team, char *name)
{
	if (team_name[team])
	{
		delete team_name[team];

		team_name[team] = NULL;
	}

	team_name[team] = new char [strlen (name) + 1];

	strcpy (team_name[team], name);
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

int tactical_mission::get_team_flag (int team)
{
	return team_flag[team];
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

void tactical_mission::set_team_flag (int team, int flag)
{
	team_flag[team] = static_cast<char>(flag);
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

void tactical_mission::setup_victory_condition (char *buffer)
{
	victory_type
		type;

	TREELIST
		*item;

	int
		team,
		vu_id_1,
		vu_id_2,
		value,
		tolerance,
		points;

	VU_ID
		id;

	victory_condition
		*vc;

	// team, type, vu_id, value, tolerance, points
	sscanf
	(
		buffer,
		"%d %d %d %d %d %d %d",
		&team,
		&type,
		&vu_id_1,
		&vu_id_2,
		&value,
		&tolerance,
		&points
	);

	id.num_ = vu_id_1;
	id.creator_ = vu_id_2;

	victory_condition::enter_critical_section ();

	vc = new victory_condition (this);

	vc->set_team (team);
	vc->set_type (type);
	vc->set_vu_id (id);
	vc->set_sub_objective (value);
	vc->set_tolerance (tolerance);
	vc->set_points (points);

	vc->control = MakeVCControl (vc);
	
	if (gVCTree)
	{
		item = gVCTree->CreateItem (vc->get_number (), C_TYPE_ITEM, vc->control);

		if (item)
		{
			gVCTree->AddItem (gVCTree->GetRoot (), item);
			((C_Victory*) vc->control)->SetOwner (item);
			vc->control->SetReady (1);
			vc->control->SetClient (gVCTree->GetClient ());
			vc->control->SetParent (gVCTree->Parent_);
			vc->control->SetSubParents (gVCTree->Parent_);
			gVCTree->RecalcSize ();
			if (gVCTree->Parent_)
				gVCTree->Parent_->RefreshClient (gVCTree->GetClient ());
		}
	}

	if (gMapMgr)
	{
		gMapMgr->AddVC (vc);
	}
	UpdateVCOptions(vc);

	victory_condition::leave_critical_section ();
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

static int test_filter (victory_condition *vc, victory_condition_filter filter, int team)
{
	victory_condition::enter_critical_section ();
	
	switch (filter)
	{
		case vcf_all:
		{
			victory_condition::leave_critical_section ();
			
			return TRUE;
		}
		
		case vcf_team:
		{
			if (team == vc->get_team ())
			{
				victory_condition::leave_critical_section ();
				
				return TRUE;
			}
			
			break;
		}
		
		case vcf_all_achieved:
		{
			if (vc->get_active ())
			{
				victory_condition::leave_critical_section ();
				
				return TRUE;
			}
			
			break;
		}
		
		case vcf_all_remaining:
		{
			if (!vc->get_active ())
			{
				victory_condition::leave_critical_section ();
				
				return TRUE;
			}
			
			break;
		}
		
		case vcf_team_achieved:
		{
			if
				(
				(team == vc->get_team ()) &&
				(vc->get_active ())
				)
			{
				victory_condition::leave_critical_section ();
				
				return TRUE;
			}
			
			break;
		}
		
		case vcf_team_remaining:
		{
			if
				(
				(team == vc->get_team ()) &&
				(!vc->get_active ())
				)
			{
				victory_condition::leave_critical_section ();
				
				return TRUE;
			}
			
			break;
		}
	}
	
	victory_condition::leave_critical_section ();
	
	return FALSE;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

void tactical_mission::set_victory_condition_filter (victory_condition_filter new_filter)
{
	filter = new_filter;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

void tactical_mission::set_victory_condition_team_filter (int new_team)
{
	team = new_team;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

victory_condition *tactical_mission::get_first_victory_condition (void)
{
	victory_condition::enter_critical_section ();

	current_vc = conditions;

	while (current_vc)
	{
		if (test_filter (current_vc, filter, team))
		{
			break;
		}

		current_vc = current_vc->succ;
	}

	victory_condition::leave_critical_section ();

	return current_vc;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

victory_condition *tactical_mission::get_next_victory_condition (void)
{
	victory_condition::enter_critical_section ();

	current_vc = current_vc->succ;