Pseudo Film Farm Implementation

interface\film_farm\film_farm.cpp

/* ---------- headers */

#include "interface/film_farm/film_farm.h"

#include "interface/film_farm/film_farm_manager.h"

/* ---------- constants */

/* ---------- definitions */

/* ---------- prototypes */

// call in
//     user_interface_initialize
extern void film_farm_initialize();

// call in
//     user_interface_dispose
extern void film_farm_dispose();

// call in
//     user_interface_update
extern void film_farm_update();

// call in
//     main_halt_and_catch_fire
//     c_saved_film_director::update
//     input_has_gamepad
//     damaged_media_halt_and_display_error
//     c_gui_error_manager::post_error_with_custom_message
extern bool film_farm_is_active();

extern bool film_farm_is_enabled();

// call in
//     main_halt_and_catch_fire
//     damaged_media_halt_and_display_error
//     c_gui_error_manager::post_error_with_custom_message
extern void film_farm_fail(e_film_farm_failure_type failure_type);

/* ---------- globals */

bool g_film_farm_enabled = false;
c_typed_opaque_data<c_film_farm_manager, sizeof(c_film_farm_manager), 8> g_film_farm_manager;

/* ---------- private variables */

/* ---------- public code */

void film_farm_initialize()
{
	g_film_farm_manager.construct();
}

void film_farm_dispose()
{
	g_film_farm_manager.destruct();
}

void film_farm_update()
{
	if (c_film_farm_manager* film_farm_manager = g_film_farm_manager.try_and_get())
	{
		if (g_film_farm_enabled != film_farm_manager->is_enabled())
		{
			film_farm_manager->set_enabled(g_film_farm_enabled);
		}
		film_farm_manager->do_update();
	}
}

bool film_farm_is_active()
{
	bool is_active = false;
	if (c_film_farm_manager* film_farm_manager = g_film_farm_manager.try_and_get())
	{
		is_active = film_farm_manager->is_active();
	}
	return is_active
}

bool film_farm_is_enabled()
{
	bool is_enabled = false;
	if (c_film_farm_manager* film_farm_manager = g_film_farm_manager.try_and_get())
	{
		is_enabled = film_farm_manager->is_enabled();
	}
	return is_enabled
}

void film_farm_fail(e_film_farm_failure_type failure_type)
{
	if (c_film_farm_manager* film_farm_manager = g_film_farm_manager.try_and_get())
	{
		film_farm_manager->fail(failure_type);
	}
}

/* ---------- private code */

interface\film_farm\film_farm.h

#ifndef __FILM_FARM_H__
#define __FILM_FARM_H__
#pragma once

/* ---------- headers */

#include "interface/film_farm/film_farm_manager.h"

/* ---------- constants */

enum e_film_farm_failure_type;

/* ---------- definitions */

/* ---------- prototypes */

extern void film_farm_initialize();
extern void film_farm_dispose();
extern void film_farm_update();
extern bool film_farm_is_active();
extern bool film_farm_is_enabled();
extern void film_farm_fail(e_film_farm_failure_type failure_type);

/* ---------- globals */

extern bool g_film_farm_enabled;
extern c_typed_opaque_data<c_film_farm_manager, sizeof(c_film_farm_manager), 8> g_film_farm_manager;

/* ---------- public code */

/* ---------- private code */

#endif // __FILM_FARM_H__

interface\film_farm\film_farm_manager.cpp

/* ---------- headers */

#include "interface/film_farm/film_farm_manager.h"

/* ---------- constants */

/* ---------- definitions */

/* ---------- prototypes */

/* ---------- globals */

/* ---------- private variables */

/* ---------- public code */

c_film_farm_manager::c_film_farm_manager() : 
	m_enabled(false),
	m_stage(_film_farm_stage_setup),
	m_failed(false),
	m_error_string(),
	m_film_path(),
	m_film_file(),
	__unknown9(true),
{
}

bool c_film_farm_manager::is_active()
{
	return m_enabled && !m_failed && 
		IN_RANGE_INCLUSIVE(m_stage, _film_farm_stage_update_task_init, _film_farm_stage_update_task_reset);
}

bool c_film_farm_manager::is_main_menu_active()
{
	return game_in_progress() && game_is_ui_shell();
}

void c_film_farm_manager::set_enabled(bool enable)
{
	if (m_enabled != enable)
	{
		m_enabled = enable;
		if (!enable)
		{
			__unknownA = true;
		}
	}
}

bool c_film_farm_manager::is_enabled()
{
	return m_enabled;
}

void c_film_farm_manager::fail(e_film_farm_failure_type failure_type)
{
	if (!m_failed)
	{
		m_failed = true;

		s_file_reference error_file{};
		switch (failure_type)
		{
		case _film_farm_failure_type_crash:
			file_reference_create_from_path(&error_file, "film_playback\\error-crash.txt", false);
			break;
		case _film_farm_failure_type_oos:
			file_reference_create_from_path(&error_file, "film_playback\\error-oos.txt", false);
			break;
		case _film_farm_failure_type_dirty_disk:
			file_reference_create_from_path(&error_file, "film_playback\\error-dirty_disk.txt", false);
			break;
		}
		file_create(&error_file);
	}
}

void c_film_farm_manager::save_error()
{
	s_file_reference error_file{};
	file_reference_create_from_path(&error_file, "film_playback\\error.txt", false);

	unsigned long error = 0;
	if (file_create(&error_file) && file_open(&error_file, FLAG(_permission_write_bit), &error))
	{
		file_write(&error_file, m_error_string.length(), m_error_string.get_string());
		file_close(&error_file);
	}
}

void c_film_farm_manager::reset_errors()
{
	s_file_reference error_file{};
	file_reference_create_from_path(&error_file, "film_playback\\error.txt", false);
	if (file_exists(&error_file))
	{
		file_delete(&error_file);
	}

	s_file_reference crash_file{};
	file_reference_create_from_path(&crash_file, "film_playback\\error-crash.txt", false);
	if (file_exists(&crash_file))
	{
		file_delete(&crash_file);
	}

	s_file_reference oos_file{};
	file_reference_create_from_path(&oos_file, "film_playback\\error-oos.txt", false);
	if (file_exists(&oos_file))
	{
		file_delete(&oos_file);
	}

	s_file_reference dirty_disk_file{};
	file_reference_create_from_path(&dirty_disk_file, "film_playback\\error-dirty_disk.txt", false);
	if (file_exists(&dirty_disk_file))
	{
		file_delete(&dirty_disk_file);
	}
}

void c_film_farm_manager::reset_task(bool reset)
{
	__int64 timestamp = time(0);
	__time2B8A0 = timestamp;
	__time2B8B0 = timestamp;
	__time2B8A8 = timestamp;

	m_film_path.clear();

	m_hud_state = (e_observer_director_show_hud_state)1; // $TODO

	s_file_reference load_file{};
	file_reference_create_from_path(&load_file, "film_playback\\1-load.txt", false);
	if (file_exists(&load_file) && !reset)
	{
		file_delete(&load_file);
	}

	s_file_reference ready_file{};
	file_reference_create_from_path(&ready_file, "film_playback\\2-ready.txt", false);
	if (file_exists(&ready_file))
	{
		file_delete(&ready_file);
	}

	s_file_reference go_file{};
	file_reference_create_from_path(&go_file, "film_playback\\3-go.txt", false);
	if (file_exists(&go_file))
	{
		file_delete(&go_file);
	}

	s_file_reference film_complete_file{};
	file_reference_create_from_path(&film_complete_file, "film_playback\\4-film_complete.txt", false);
	if (file_exists(&film_complete_file))
	{
		file_delete(&film_complete_file);
	}

	s_file_reference return_file{};
	file_reference_create_from_path(&return_file, "film_playback\\5-return.txt", false);
	if (file_exists(&return_file))
	{
		file_delete(&return_file);
	}
}

void c_film_farm_manager::do_update()
{
	if (__unknownA)
	{
		__unknownA = false;
		m_stage = _film_farm_stage_setup;
		m_failed = false;
	}

	if (m_enabled && !m_failed)
	{
		e_film_farm_stage stage = m_stage;
		switch (stage)
		{
		case _film_farm_stage_setup:
			stage = update_setup();
			break;
		case _film_farm_stage_update_setup_wait_for_main_menu:
			stage = update_setup_wait_for_main_menu();
			break;
		case _film_farm_stage_update_setup_wait_for_task:
			stage = update_setup_wait_for_task();
			break;
		case _film_farm_stage_update_task_init:
			stage = update_task_init();
			break;
		case _film_farm_stage_update_task_wait_for_lobby:
			stage = update_task_wait_for_lobby();
			break;
		case _film_farm_stage_update_task_wait_for_pregame_ready_then_game_loaded:
			stage = update_task_wait_for_pregame_ready_then_game_loaded();
			break;
		case _film_farm_stage_update_task_wait_for_film_prepared:
			stage = update_task_wait_for_film_prepared();
			break;
		case _film_farm_stage_update_task_wait_for_first_frame_stable_state:
			stage = update_task_wait_for_first_frame_stable_state();
			break;
		case _film_farm_stage_update_task_wait_for_go_message:
			stage = update_task_wait_for_go_message();
			break;
		case _film_farm_stage_update_task_wait_for_film_to_complete:
			stage = update_task_wait_for_film_to_complete();
			break;
		case _film_farm_stage_update_task_wait_for_return_to_menu_message:
			stage = update_task_wait_for_return_to_menu_message();
			break;
		case _film_farm_stage_update_task_wait_for_return_to_menu:
			stage = update_task_wait_for_return_to_menu();
			break;
		case _film_farm_stage_update_task_error:
			stage = update_task_error();
			break;
		case _film_farm_stage_update_task_reset:
			stage = update_task_reset();
			break;
		case _film_farm_stage_update_unknown:
			break;
		default:
			unreachable();
			break;
		}
		m_state = state;
	}
}

e_film_farm_stage c_film_farm_manager::update_setup()
{
	reset_task(true);
	reset_errors();
	return _film_farm_stage_update_setup_wait_for_main_menu;
}

e_film_farm_stage c_film_farm_manager::update_setup_wait_for_main_menu()
{
	e_film_farm_stage stage = _film_farm_stage_update_setup_wait_for_main_menu;
	__int64 timestamp = time(0);
	if (difftime64(timestamp, __time2B8A0) > 1.0f)
	{
		__time2B8A0 = timestamp;
		if (is_main_menu_active())
		{
			stage = _film_farm_stage_update_setup_wait_for_task;
		}
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_setup_wait_for_task()
{
	e_film_farm_stage stage = _film_farm_stage_update_setup_wait_for_task;
	__int64 timestamp = time(0);
	if (difftime64(timestamp, __time2B8A0) > 1.0f)
	{
		__time2B8A0 = timestamp;
		if (is_main_menu_active())
		{
			s_file_reference load_file{};
			file_reference_create_from_path(&load_file, "film_playback\\1-load.txt", false);
			if (file_exists(&load_file))
			{
				stage = _film_farm_stage_update_task_init;
			}
		}
		else
		{
			stage = _film_farm_stage_update_setup_wait_for_main_menu;
		}
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_init()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_error;
	m_error_string.set("unknown error");

	s_file_reference load_file{};
	file_reference_create_from_path(&load_file, "film_playback\\1-load.txt", false);

	unsigned long error = 0;
	if (file_exists(&load_file) && file_open(&load_file, FLAG(_permission_read_bit), &error))
	{
		unsigned long load_file_size = 0;
		c_static_string<4096> file_data;
		if (file_get_size(&load_file, &load_file_size) && load_file_size <= file_data.max_length())
		{
			if (file_read(&load_file, load_file_size, true, file_data.get_buffer()))
			{
				c_http_game_api_parser api_parser{};
				c_static_string<48> hud_state;
				c_static_string<48> timeline;

				bool valid = true;
				valid = valid && api_parser.read_string<260>("film path: ", m_film_path);
				valid = valid && api_parser.read_string<48>("hud: ", hud_state);
				valid = valid && api_parser.read_string<48>("hud timeline: ", timeline);
				if (valid)
				{
					bool use_defaults = hud_state.is_equal("default") && timeline.is_equal("default");
					if (use_defaults)
					{
						m_hud_state = _observer_director_show_hud_state_saved_film_off;
					}
					else
					{
						bool hud_state_on = hud_state.is_equal("on");
						bool timeline_on = timeline.is_equal("on");
						if (hud_state_on && timeline_on)
						{
							m_hud_state = _observer_director_show_hud_state_both_on;
						}
						else if (hud_state_on)
						{
							m_hud_state = _observer_director_show_hud_state_saved_film_off;
						}
						else
						{
							m_hud_state = _observer_director_show_hud_state_both_off;
						}
					}

					c_controller_interface* controller = controller_get(_controller0);
					if (!controller->is_signed_in_to_machine())
					{
						controller->set_as_unsigned_in_user(true);
						controller->update(0);
					}

					user_interface_networking_enter_pregame_location(_gui_game_setup_mode_theater);
					__time2B8A8 = time(0);
					stage = _film_farm_stage_update_task_wait_for_lobby;
				}
				else
				{
					stage = _film_farm_stage_update_task_error;
					m_error_string.set("failed to parse load.txt file");
				}
			}
		}
		file_close(&load_file);
	}
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_lobby()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_lobby;
	if (user_interface_squad_exists() && user_interface_get_session_game_mode() == _session_game_mode_pregame &&
	   difftime64(timestamp, __time2B8A8) > 3.0f && !saved_game_files_enumeration_in_progress())
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("unknown error");

		s_file_reference film_file{};
		file_reference_create_from_path(&film_file, m_film_path.get_string(), false);

		unsigned long error = 0;
		if (file_exists(&film_file) && file_open(&film_file, FLAG(_permission_read_bit), &error))
		{
			unsigned long film_file_size = 0;
			if (file_get_size(&film_file, &film_file_size))
			{
				if (film_file_size >= sizeof(s_blf_saved_film))
				{
					film_file_size = sizeof(s_blf_saved_film);
				}
				
				if (file_read(&film_file, film_file_size, true, &m_film_file))
				{
					set_squad_session_film(m_film_path.get_string(), &m_film_file);
					stage = _film_farm_stage_update_task_wait_for_pregame_ready_then_game_loaded;
				}
			}
			file_close(&film_file);
		}
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_pregame_ready_then_game_loaded()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_pregame_ready_then_game_loaded;
	if (user_interface_squad_exists())
	{
		e_session_game_mode game_mode = user_interface_get_session_game_mode();
		if (game_mode == _session_game_mode_pregame)
		{
			unsigend long player_error_mask = 0;
			e_session_game_start_error error = _session_game_start_error_none;
			e_session_game_start_status status = user_interface_get_session_game_start_status(&error, &player_error_mask);
			if (status != _session_game_start_status_ready || user_interface_squad_in_or_after_countdown())
			{
				if (status == _session_game_start_status_error && error != _session_game_start_error_map_load_precaching)
				{
					stage = _film_farm_stage_update_task_error;
					m_error_string.print("pregame in error state %d", error);
				}
			}
			else
			{
				user_interface_squad_start_countdown_timer(_controller0, 1, 0);
			}
		}
		else if (game_mode == _session_game_mode_ingame)
		{
			stage = _film_farm_stage_update_task_wait_for_film_prepared;
		}
	}
	else
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("not in squad");
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_film_prepared()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_film_prepared;
	if (user_interface_squad_exists() && user_interface_get_session_game_mode() == _session_game_mode_ingame)
	{
		long current_tick_estimate = saved_film_manager_get_current_tick_estimate();
		if (current_tick_estimate >= saved_film_manager_get_snippet_start_tick() && current_tick_estimate >= k_film_farm_maximum_tick_estimate)
		{
			m_error_string.set("unknown error");
			long user_index = NONE;
			for (long output_user_index = 0; output_user_index < 4; output_user_index++)
			{
				if (player_mapping_output_user_is_active(output_user_index) &&
					director_get(output_user_index)->get_type() == _camera_mode_orbiting)
				{
					user_index = output_user_index;
					break;
				}
			}
			if (user_index != NONE)
			{
				((c_observer_director*)director_get(user_index))->set_show_hud_state(m_hud_state);
			}

			saved_film_manager_set_playback_game_speed(0.0f);
			__time2B8B0 = time(0);
			stage = _film_farm_stage_update_task_wait_for_first_frame_stable_state;
		}
	}
	else
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("not in in-game squad");
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_first_frame_stable_state()
{
	__int64 timestamp = time(0);

	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_first_frame_stable_state;
	if (user_interface_squad_exists() && user_interface_get_session_game_mode() == _session_game_mode_ingame)
	{
		if (difftime64(timestamp, __time2B8B0) > 2.0f)
		{
			s_file_reference &ready_file {};
			file_reference_create_from_path(&ready_file, "film_playback\\2-ready.txt", false);
			if (file_exists(&ready_file))
			{
				stage = _film_farm_stage_update_task_wait_for_go_message;
			}
			else
			{
				stage = _film_farm_stage_update_task_error;
			}
		}
	}
	else
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("not in in-game squad");
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_go_message()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_go_message;
	if (user_interface_squad_exists() && user_interface_get_session_game_mode() == _session_game_mode_ingame)
	{
		s_file_reference go_file{};
		file_reference_create_from_path(&go_file, "film_playback\\3-go.txt", false);
		if (file_exists(&go_file))
		{
			saved_film_manager_set_playback_game_speed(1.0f);
			stage = _film_farm_stage_update_task_wait_for_film_to_complete;
		}
	}
	else
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("not in in-game squad");
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_film_to_complete()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_film_to_complete;
	if (user_interface_squad_exists() && user_interface_get_session_game_mode() == _session_game_mode_ingame)
	{
		if (saved_film_manager_get_current_tick() >= saved_film_manager_get_length_in_ticks())
		{
			saved_film_manager_set_playback_game_speed(0.0f);
			stage = _film_farm_stage_update_task_error;
			m_error_string.set("unknown error");

			s_file_reference film_complete_file{};
			file_reference_create_from_path(&film_complete_file, "film_playback\\4-film_complete.txt", false);
			if (file_create(&film_complete_file))
			{
				stage = _film_farm_stage_update_task_wait_for_return_to_menu_message;
			}
		}
	}
	else
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("not in in-game squad");
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_return_to_menu_message()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_return_to_menu_message;
	if (user_interface_squad_exists() && user_interface_get_session_game_mode() == _session_game_mode_ingame)
	{
		s_file_reference return_file{};
		file_reference_create_from_path(&return_file, "film_playback\\5-return.txt", false);
		if (file_exists(&return_file))
		{
			saved_film_manager_request_end_film();
			stage = _film_farm_stage_update_task_wait_for_return_to_menu;
		}
	}
	else
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("not in in-game squad");
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_wait_for_return_to_menu()
{
	e_film_farm_stage stage = _film_farm_stage_update_task_wait_for_return_to_menu;
	if (user_interface_squad_exists())
	{
		if (user_interface_get_session_game_mode() == _session_game_mode_pregame)
		{
			stage = _film_farm_stage_update_task_reset;
		}
	}
	else
	{
		stage = _film_farm_stage_update_task_error;
		m_error_string.set("not in squad or main menu");
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_error()
{
	save_error();

	e_film_farm_stage stage = _film_farm_stage_update_unknown;
	if (__unknown9)
	{
		if (user_interface_squad_exists() && user_interface_get_session_game_mode() == _session_game_mode_ingame)
		{
			if (game_is_authoritative_playback())
			{
				if (!saved_film_manager_film_is_ended(nullptr))
				{
					saved_film_manager_request_end_film();
				}
			}
		}
		else
		{
			user_interface_squad_end_game();
		}

		stage = _film_farm_stage_update_task_reset;
	}
	else (game_in_progress() && !game_is_ui_shell())
	{
		main_menu_launch();
	}
	return stage;
}

e_film_farm_stage c_film_farm_manager::update_task_reset()
{
	reset_task(false);
	return _film_farm_stage_update_setup_wait_for_main_menu;
}

/* ---------- private code */

interface\film_farm\film_farm_manager.h

#ifndef __FILM_FARM_MANAGER_H__
#define __FILM_FARM_MANAGER_H__
#pragma once

/* ---------- headers */

/* ---------- constants */

/* ---------- definitions */

struct c_film_farm_manager
{
	bool m_enabled;
	e_film_farm_stage m_stage;
	bool m_failed;

	bool __unknown9;
	bool __unknownA;

	c_static_string<1024> m_error_string;
	c_static_string<1024> m_film_path;

	unsigned char __pad510[1];
	s_blf_saved_film m_film_file;

	unsigned char __data2B894[12];

	__int64 __time2B8A0;
	__int64 __time2B8A8;
	__int64 __time2B8B0;

	e_observer_director_show_hud_state m_hud_state;
};
//static_assert(sizeof(c_film_farm_manager) == 0x?????);

class c_film_farm_manager
{
	c_film_farm_manager();

	bool is_active();
	bool is_main_menu_active();

	void set_enabled(bool enable);
	bool is_enabled();

	void fail(e_film_farm_failure_type failure_type);

	void save_error();
	void reset_errors();

	void reset_task(bool reset);

	void do_update();

	e_film_farm_stage update_setup();
	e_film_farm_stage update_setup_wait_for_main_menu();
	e_film_farm_stage update_setup_wait_for_task();
	e_film_farm_stage update_task_init();
	e_film_farm_stage update_task_wait_for_lobby();
	e_film_farm_stage update_task_wait_for_pregame_ready_then_game_loaded();
	e_film_farm_stage update_task_wait_for_film_prepared();
	e_film_farm_stage update_task_wait_for_first_frame_stable_state();
	e_film_farm_stage update_task_wait_for_go_message();
	e_film_farm_stage update_task_wait_for_film_to_complete();
	e_film_farm_stage update_task_wait_for_return_to_menu_message();
	e_film_farm_stage update_task_wait_for_return_to_menu();
	e_film_farm_stage update_task_error();
	e_film_farm_stage update_task_reset();
};

/* ---------- prototypes */

/* ---------- globals */

/* ---------- public code */

/* ---------- private code */

#endif // __FILM_FARM_MANAGER_H__