pub const ANVIL_API_VERSION: u32 = 2;
pub const ANVIL_EVENT_PLUGINS_LOADED: &[u8; 21] = b"anvil.plugins_loaded\0";
pub const ANVIL_EVENT_SUSPENDED: &[u8; 16] = b"anvil.suspended\0";
pub const ANVIL_EVENT_RESUMED: &[u8; 14] = b"anvil.resumed\0";
pub const ANVIL_GAME_ID: &[u8; 11] = b"anvil-game\0";
pub const ANVIL_GAME_EVENT_READY: &[u8; 17] = b"anvil-game.ready\0";
pub const ANVIL_GAME_EVENT_FRAME: &[u8; 17] = b"anvil-game.frame\0";
pub const ANVIL_GAME_EVENT_SESSION: &[u8; 19] = b"anvil-game.session\0";
pub const ANVIL_GAME_EVENT_MAIN_MENU: &[u8; 21] = b"anvil-game.main_menu\0";
pub const ANVIL_GAME_SERVICE: &[u8; 16] = b"anvil-game.game\0";
pub const ANVIL_GAME_SERVICE_VERSION: u32 = 1;
pub const ANVIL_GAME_OOS_DETECTED: u32 = 1;
pub const ANVIL_GAME_OOS_PAUSED: u32 = 2;
pub const ANVIL_GAME_EVENT_OOS: &[u8; 15] = b"anvil-game.oos\0";
pub const ANVIL_GAME_EVENT_DAY: &[u8; 15] = b"anvil-game.day\0";
pub const ANVIL_GAME_EVENT_MONTH: &[u8; 17] = b"anvil-game.month\0";
pub const ANVIL_GAME_EVENT_YEAR: &[u8; 16] = b"anvil-game.year\0";
pub const ANVIL_GAME_EVENT_PLAYER: &[u8; 18] = b"anvil-game.player\0";
pub const ANVIL_GAME_EVENT_WAR: &[u8; 15] = b"anvil-game.war\0";
pub const ANVIL_GAME_PROVINCE_LAND: u32 = 1;
pub const ANVIL_GAME_PROVINCE_WASTELAND: u32 = 2;
pub const ANVIL_GAME_COUNTRY_OBSERVER: u32 = 1;
pub const ANVIL_GAME_VALUE_TREASURY: u32 = 1;
pub const ANVIL_GAME_VALUE_STABILITY: u32 = 2;
pub const ANVIL_GAME_VALUE_PRESTIGE: u32 = 4;
pub const ANVIL_GAME_VALUE_MANPOWER: u32 = 8;
pub const ANVIL_GAME_VALUE_MONTHLY_INCOME: u32 = 16;
pub const ANVIL_GAME_WAR_ATTACKERS: u32 = 0;
pub const ANVIL_GAME_WAR_DEFENDERS: u32 = 1;
pub const ANVIL_GAME_UNIT_ARMY: u32 = 0;
pub const ANVIL_GAME_UNIT_NAVY: u32 = 1;
pub const ANVIL_GAME_MISSION_UNKNOWN: i32 = -1;
pub const ANVIL_GAME_MISSION_NONE: u32 = 0;
pub const ANVIL_GAME_MISSION_PROTECT_TRADE: u32 = 1;
pub const ANVIL_GAME_MISSION_PRIVATEER: u32 = 2;
pub const ANVIL_GAME_MISSION_HUNT_PIRATES: u32 = 3;
pub const ANVIL_GAME_MISSION_PATROL: u32 = 4;
pub const ANVIL_GAME_MISSION_EXPLORE: u32 = 5;
pub const ANVIL_GAME_MISSION_EVADE: u32 = 6;
pub const ANVIL_GAME_MISSION_HUNT_FLEETS: u32 = 7;
pub const ANVIL_GAME_MISSION_BLOCKADE: u32 = 8;
pub const ANVIL_GAME_MISSION_INTERCEPT: u32 = 9;
pub const ANVIL_GAME_MISSION_REPAIR: u32 = 10;
pub const ANVIL_GAME_MISSION_CIRCUMNAVIGATE: u32 = 11;
pub const ANVIL_GAME_MISSION_EXPLORE_LAND: u32 = 12;
pub const ANVIL_GAME_MISSION_HUNT_REBELS: u32 = 13;
pub const ANVIL_GAME_MISSION_SIEGE: u32 = 14;
pub const ANVIL_GAME_MISSION_DRILL: u32 = 15;
pub const ANVIL_GAME_WORLD_SERVICE: &[u8; 17] = b"anvil-game.world\0";
pub const ANVIL_GAME_WORLD_SERVICE_VERSION: u32 = 1;
pub const ANVIL_OVERLAY_ID: &[u8; 14] = b"anvil-overlay\0";
pub const ANVIL_PANEL_SERVICE: &[u8; 20] = b"anvil-overlay.panel\0";
pub const ANVIL_PANEL_SERVICE_VERSION: u32 = 1;
pub const ANVIL_BENCHMARK_SERVICE: &[u8; 16] = b"anvil.benchmark\0";
pub const ANVIL_BENCHMARK_SERVICE_VERSION: u32 = 1;
pub const ANVIL_BENCHMARK_EVENT_QUIT: &[u8; 21] = b"anvil.benchmark_quit\0";
pub const ANVIL_BENCHMARK_QUIT_LIMIT_MS: u32 = 30000;
pub const ANVIL_BENCHMARK_MAX_FIELDS: u32 = 128;
pub const ANVIL_BENCHMARK_MAX_OPTIONS: u32 = 32;
pub const ANVIL_BENCHMARK_MAX_NAME: u32 = 64;
pub const ANVIL_BENCHMARK_MAX_LABEL: u32 = 80;
pub const ANVIL_MAP_ID: &[u8; 10] = b"anvil-map\0";
pub const ANVIL_MAP_MODES_SERVICE: &[u8; 16] = b"anvil-map.modes\0";
pub const ANVIL_MAP_MODES_SERVICE_VERSION: u32 = 1;
pub const ANVIL_MAP_EVENT_SHOWN: &[u8; 16] = b"anvil-map.shown\0";
pub const ANVIL_MAP_EVENT_HIDDEN: &[u8; 17] = b"anvil-map.hidden\0";
pub const ANVIL_MAP_NO_COLOR: u32 = 4278190080;
pub type wchar_t = core::ffi::c_ushort;
#[repr(C)]
#[derive(Debug)]
pub struct AnvilPlugin {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug)]
pub struct AnvilChange {
_unused: [u8; 0],
}
pub type AnvilSymbol = u32;
pub type AnvilSetting = u32;
pub const ANVIL_OK: AnvilResult = 0;
pub const ANVIL_ERROR_INVALID_ARGUMENT: AnvilResult = 1;
pub const ANVIL_ERROR_NOT_DECLARED: AnvilResult = 2;
pub const ANVIL_ERROR_WRONG_KIND: AnvilResult = 3;
pub const ANVIL_ERROR_CONFLICT: AnvilResult = 4;
pub const ANVIL_ERROR_UNSAFE_SITE: AnvilResult = 5;
pub const ANVIL_ERROR_BYTES_MISMATCH: AnvilResult = 6;
pub const ANVIL_ERROR_OUT_OF_MEMORY: AnvilResult = 7;
pub const ANVIL_ERROR_WRONG_PHASE: AnvilResult = 8;
pub const ANVIL_ERROR_UNSUPPORTED: AnvilResult = 9;
pub const ANVIL_ERROR_INTERNAL: AnvilResult = 10;
pub const ANVIL_ERROR_NOT_FOUND: AnvilResult = 11;
pub const ANVIL_ERROR_ALREADY_EXISTS: AnvilResult = 12;
pub type AnvilResult = core::ffi::c_int;
pub const ANVIL_LOG_DEBUG: AnvilLogLevel = 0;
pub const ANVIL_LOG_INFO: AnvilLogLevel = 1;
pub const ANVIL_LOG_WARNING: AnvilLogLevel = 2;
pub const ANVIL_LOG_ERROR: AnvilLogLevel = 3;
pub type AnvilLogLevel = core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameInfo {
pub size: u32,
pub build_id: *const core::ffi::c_char,
pub image_base: usize,
pub image_size: u32,
pub sha256: *const core::ffi::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameInfo"][::core::mem::size_of::<AnvilGameInfo>() - 40usize];
["Alignment of AnvilGameInfo"][::core::mem::align_of::<AnvilGameInfo>() - 8usize];
[
"Offset of field: AnvilGameInfo::size",
][::core::mem::offset_of!(AnvilGameInfo, size) - 0usize];
[
"Offset of field: AnvilGameInfo::build_id",
][::core::mem::offset_of!(AnvilGameInfo, build_id) - 8usize];
[
"Offset of field: AnvilGameInfo::image_base",
][::core::mem::offset_of!(AnvilGameInfo, image_base) - 16usize];
[
"Offset of field: AnvilGameInfo::image_size",
][::core::mem::offset_of!(AnvilGameInfo, image_size) - 24usize];
[
"Offset of field: AnvilGameInfo::sha256",
][::core::mem::offset_of!(AnvilGameInfo, sha256) - 32usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub union AnvilXmm {
pub u8_: [u8; 16usize],
pub u16_: [u16; 8usize],
pub u32_: [u32; 4usize],
pub u64_: [u64; 2usize],
pub f32_: [f32; 4usize],
pub f64_: [f64; 2usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilXmm"][::core::mem::size_of::<AnvilXmm>() - 16usize];
["Alignment of AnvilXmm"][::core::mem::align_of::<AnvilXmm>() - 8usize];
["Offset of field: AnvilXmm::u8_"][::core::mem::offset_of!(AnvilXmm, u8_) - 0usize];
[
"Offset of field: AnvilXmm::u16_",
][::core::mem::offset_of!(AnvilXmm, u16_) - 0usize];
[
"Offset of field: AnvilXmm::u32_",
][::core::mem::offset_of!(AnvilXmm, u32_) - 0usize];
[
"Offset of field: AnvilXmm::u64_",
][::core::mem::offset_of!(AnvilXmm, u64_) - 0usize];
[
"Offset of field: AnvilXmm::f32_",
][::core::mem::offset_of!(AnvilXmm, f32_) - 0usize];
[
"Offset of field: AnvilXmm::f64_",
][::core::mem::offset_of!(AnvilXmm, f64_) - 0usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct AnvilCpuContext {
pub xmm: [AnvilXmm; 16usize],
pub rflags: usize,
pub r15: usize,
pub r14: usize,
pub r13: usize,
pub r12: usize,
pub r11: usize,
pub r10: usize,
pub r9: usize,
pub r8: usize,
pub rdi: usize,
pub rsi: usize,
pub rdx: usize,
pub rcx: usize,
pub rbx: usize,
pub rax: usize,
pub rbp: usize,
pub rsp: usize,
pub reserved: usize,
pub rip: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilCpuContext"][::core::mem::size_of::<AnvilCpuContext>() - 408usize];
[
"Alignment of AnvilCpuContext",
][::core::mem::align_of::<AnvilCpuContext>() - 8usize];
[
"Offset of field: AnvilCpuContext::xmm",
][::core::mem::offset_of!(AnvilCpuContext, xmm) - 0usize];
[
"Offset of field: AnvilCpuContext::rflags",
][::core::mem::offset_of!(AnvilCpuContext, rflags) - 256usize];
[
"Offset of field: AnvilCpuContext::r15",
][::core::mem::offset_of!(AnvilCpuContext, r15) - 264usize];
[
"Offset of field: AnvilCpuContext::r14",
][::core::mem::offset_of!(AnvilCpuContext, r14) - 272usize];
[
"Offset of field: AnvilCpuContext::r13",
][::core::mem::offset_of!(AnvilCpuContext, r13) - 280usize];
[
"Offset of field: AnvilCpuContext::r12",
][::core::mem::offset_of!(AnvilCpuContext, r12) - 288usize];
[
"Offset of field: AnvilCpuContext::r11",
][::core::mem::offset_of!(AnvilCpuContext, r11) - 296usize];
[
"Offset of field: AnvilCpuContext::r10",
][::core::mem::offset_of!(AnvilCpuContext, r10) - 304usize];
[
"Offset of field: AnvilCpuContext::r9",
][::core::mem::offset_of!(AnvilCpuContext, r9) - 312usize];
[
"Offset of field: AnvilCpuContext::r8",
][::core::mem::offset_of!(AnvilCpuContext, r8) - 320usize];
[
"Offset of field: AnvilCpuContext::rdi",
][::core::mem::offset_of!(AnvilCpuContext, rdi) - 328usize];
[
"Offset of field: AnvilCpuContext::rsi",
][::core::mem::offset_of!(AnvilCpuContext, rsi) - 336usize];
[
"Offset of field: AnvilCpuContext::rdx",
][::core::mem::offset_of!(AnvilCpuContext, rdx) - 344usize];
[
"Offset of field: AnvilCpuContext::rcx",
][::core::mem::offset_of!(AnvilCpuContext, rcx) - 352usize];
[
"Offset of field: AnvilCpuContext::rbx",
][::core::mem::offset_of!(AnvilCpuContext, rbx) - 360usize];
[
"Offset of field: AnvilCpuContext::rax",
][::core::mem::offset_of!(AnvilCpuContext, rax) - 368usize];
[
"Offset of field: AnvilCpuContext::rbp",
][::core::mem::offset_of!(AnvilCpuContext, rbp) - 376usize];
[
"Offset of field: AnvilCpuContext::rsp",
][::core::mem::offset_of!(AnvilCpuContext, rsp) - 384usize];
[
"Offset of field: AnvilCpuContext::reserved",
][::core::mem::offset_of!(AnvilCpuContext, reserved) - 392usize];
[
"Offset of field: AnvilCpuContext::rip",
][::core::mem::offset_of!(AnvilCpuContext, rip) - 400usize];
};
pub type AnvilCpuCallback = ::core::option::Option<
unsafe extern "C" fn(cpu: *mut AnvilCpuContext, user: *mut core::ffi::c_void),
>;
pub type AnvilEventCallback = ::core::option::Option<
unsafe extern "C" fn(
event: *const core::ffi::c_char,
payload: *const core::ffi::c_void,
context: *mut core::ffi::c_void,
),
>;
pub type AnvilSettingCallback = ::core::option::Option<
unsafe extern "C" fn(setting: AnvilSetting, context: *mut core::ffi::c_void),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilHost {
pub size: u32,
pub api_version: u32,
pub anvil_version: *const core::ffi::c_char,
pub game: *const AnvilGameInfo,
pub log: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
level: AnvilLogLevel,
message: *const core::ffi::c_char,
),
>,
pub plugin_dir: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin) -> *const wchar_t,
>,
pub data_dir: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin) -> *const wchar_t,
>,
pub hook_function: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
fn_: AnvilSymbol,
detour: *mut core::ffi::c_void,
next: *mut *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub mid_hook: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
site: AnvilSymbol,
callback: AnvilCpuCallback,
user: *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub replace_block: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
block: AnvilSymbol,
callback: AnvilCpuCallback,
user: *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub redirect_call: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
call_site: AnvilSymbol,
target: *mut core::ffi::c_void,
next: *mut *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub patch_bytes: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
site: AnvilSymbol,
bytes: *const core::ffi::c_void,
size: usize,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub swap_pointer: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
slot: AnvilSymbol,
value: *mut core::ffi::c_void,
previous: *mut *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub replace_import: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
module: *const core::ffi::c_char,
function: *const core::ffi::c_char,
replacement: *mut core::ffi::c_void,
next: *mut *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub hook_function_at: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
address: *mut core::ffi::c_void,
expected_prologue: *const core::ffi::c_void,
prologue_size: usize,
detour: *mut core::ffi::c_void,
next: *mut *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub mid_hook_at: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
address: *mut core::ffi::c_void,
expected: *const core::ffi::c_void,
expected_size: usize,
callback: AnvilCpuCallback,
user: *mut core::ffi::c_void,
out: *mut *mut AnvilChange,
) -> AnvilResult,
>,
pub remove: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
change: *mut AnvilChange,
) -> AnvilResult,
>,
pub begin_group: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin) -> AnvilResult,
>,
pub commit_group: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin) -> AnvilResult,
>,
pub abort_group: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin),
>,
pub address_of: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
symbol: AnvilSymbol,
) -> *mut core::ffi::c_void,
>,
pub symbol_value: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
symbol: AnvilSymbol,
name: *const core::ffi::c_char,
out: *mut u64,
) -> AnvilResult,
>,
pub setting_bool: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
setting: AnvilSetting,
) -> core::ffi::c_int,
>,
pub setting_int: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin, setting: AnvilSetting) -> i64,
>,
pub setting_float: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin, setting: AnvilSetting) -> f64,
>,
pub setting_string: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
setting: AnvilSetting,
) -> *const core::ffi::c_char,
>,
pub subscribe_setting: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
setting: AnvilSetting,
callback: AnvilSettingCallback,
context: *mut core::ffi::c_void,
) -> AnvilResult,
>,
pub register_service: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
name: *const core::ffi::c_char,
version: u32,
service: *const core::ffi::c_void,
) -> AnvilResult,
>,
pub get_service: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
name: *const core::ffi::c_char,
version: u32,
) -> *const core::ffi::c_void,
>,
pub subscribe: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
event: *const core::ffi::c_char,
callback: AnvilEventCallback,
context: *mut core::ffi::c_void,
) -> AnvilResult,
>,
pub publish: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
event: *const core::ffi::c_char,
payload: *const core::ffi::c_void,
) -> AnvilResult,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilHost"][::core::mem::size_of::<AnvilHost>() - 240usize];
["Alignment of AnvilHost"][::core::mem::align_of::<AnvilHost>() - 8usize];
[
"Offset of field: AnvilHost::size",
][::core::mem::offset_of!(AnvilHost, size) - 0usize];
[
"Offset of field: AnvilHost::api_version",
][::core::mem::offset_of!(AnvilHost, api_version) - 4usize];
[
"Offset of field: AnvilHost::anvil_version",
][::core::mem::offset_of!(AnvilHost, anvil_version) - 8usize];
[
"Offset of field: AnvilHost::game",
][::core::mem::offset_of!(AnvilHost, game) - 16usize];
[
"Offset of field: AnvilHost::log",
][::core::mem::offset_of!(AnvilHost, log) - 24usize];
[
"Offset of field: AnvilHost::plugin_dir",
][::core::mem::offset_of!(AnvilHost, plugin_dir) - 32usize];
[
"Offset of field: AnvilHost::data_dir",
][::core::mem::offset_of!(AnvilHost, data_dir) - 40usize];
[
"Offset of field: AnvilHost::hook_function",
][::core::mem::offset_of!(AnvilHost, hook_function) - 48usize];
[
"Offset of field: AnvilHost::mid_hook",
][::core::mem::offset_of!(AnvilHost, mid_hook) - 56usize];
[
"Offset of field: AnvilHost::replace_block",
][::core::mem::offset_of!(AnvilHost, replace_block) - 64usize];
[
"Offset of field: AnvilHost::redirect_call",
][::core::mem::offset_of!(AnvilHost, redirect_call) - 72usize];
[
"Offset of field: AnvilHost::patch_bytes",
][::core::mem::offset_of!(AnvilHost, patch_bytes) - 80usize];
[
"Offset of field: AnvilHost::swap_pointer",
][::core::mem::offset_of!(AnvilHost, swap_pointer) - 88usize];
[
"Offset of field: AnvilHost::replace_import",
][::core::mem::offset_of!(AnvilHost, replace_import) - 96usize];
[
"Offset of field: AnvilHost::hook_function_at",
][::core::mem::offset_of!(AnvilHost, hook_function_at) - 104usize];
[
"Offset of field: AnvilHost::mid_hook_at",
][::core::mem::offset_of!(AnvilHost, mid_hook_at) - 112usize];
[
"Offset of field: AnvilHost::remove",
][::core::mem::offset_of!(AnvilHost, remove) - 120usize];
[
"Offset of field: AnvilHost::begin_group",
][::core::mem::offset_of!(AnvilHost, begin_group) - 128usize];
[
"Offset of field: AnvilHost::commit_group",
][::core::mem::offset_of!(AnvilHost, commit_group) - 136usize];
[
"Offset of field: AnvilHost::abort_group",
][::core::mem::offset_of!(AnvilHost, abort_group) - 144usize];
[
"Offset of field: AnvilHost::address_of",
][::core::mem::offset_of!(AnvilHost, address_of) - 152usize];
[
"Offset of field: AnvilHost::symbol_value",
][::core::mem::offset_of!(AnvilHost, symbol_value) - 160usize];
[
"Offset of field: AnvilHost::setting_bool",
][::core::mem::offset_of!(AnvilHost, setting_bool) - 168usize];
[
"Offset of field: AnvilHost::setting_int",
][::core::mem::offset_of!(AnvilHost, setting_int) - 176usize];
[
"Offset of field: AnvilHost::setting_float",
][::core::mem::offset_of!(AnvilHost, setting_float) - 184usize];
[
"Offset of field: AnvilHost::setting_string",
][::core::mem::offset_of!(AnvilHost, setting_string) - 192usize];
[
"Offset of field: AnvilHost::subscribe_setting",
][::core::mem::offset_of!(AnvilHost, subscribe_setting) - 200usize];
[
"Offset of field: AnvilHost::register_service",
][::core::mem::offset_of!(AnvilHost, register_service) - 208usize];
[
"Offset of field: AnvilHost::get_service",
][::core::mem::offset_of!(AnvilHost, get_service) - 216usize];
[
"Offset of field: AnvilHost::subscribe",
][::core::mem::offset_of!(AnvilHost, subscribe) - 224usize];
[
"Offset of field: AnvilHost::publish",
][::core::mem::offset_of!(AnvilHost, publish) - 232usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameFrame {
pub size: u32,
pub reserved: u32,
pub number: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameFrame"][::core::mem::size_of::<AnvilGameFrame>() - 16usize];
["Alignment of AnvilGameFrame"][::core::mem::align_of::<AnvilGameFrame>() - 8usize];
[
"Offset of field: AnvilGameFrame::size",
][::core::mem::offset_of!(AnvilGameFrame, size) - 0usize];
[
"Offset of field: AnvilGameFrame::reserved",
][::core::mem::offset_of!(AnvilGameFrame, reserved) - 4usize];
[
"Offset of field: AnvilGameFrame::number",
][::core::mem::offset_of!(AnvilGameFrame, number) - 8usize];
};
pub const ANVIL_GAME_SESSION_STARTED: AnvilGameSessionChange = 1;
pub const ANVIL_GAME_SESSION_ENDED: AnvilGameSessionChange = 2;
pub type AnvilGameSessionChange = core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameSession {
pub size: u32,
pub change: u32,
pub ironman: u32,
pub multiplayer: u32,
pub number: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameSession"][::core::mem::size_of::<AnvilGameSession>() - 24usize];
[
"Alignment of AnvilGameSession",
][::core::mem::align_of::<AnvilGameSession>() - 8usize];
[
"Offset of field: AnvilGameSession::size",
][::core::mem::offset_of!(AnvilGameSession, size) - 0usize];
[
"Offset of field: AnvilGameSession::change",
][::core::mem::offset_of!(AnvilGameSession, change) - 4usize];
[
"Offset of field: AnvilGameSession::ironman",
][::core::mem::offset_of!(AnvilGameSession, ironman) - 8usize];
[
"Offset of field: AnvilGameSession::multiplayer",
][::core::mem::offset_of!(AnvilGameSession, multiplayer) - 12usize];
[
"Offset of field: AnvilGameSession::number",
][::core::mem::offset_of!(AnvilGameSession, number) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameDate {
pub size: u32,
pub year: i32,
pub month: u32,
pub day: u32,
pub session: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameDate"][::core::mem::size_of::<AnvilGameDate>() - 24usize];
["Alignment of AnvilGameDate"][::core::mem::align_of::<AnvilGameDate>() - 8usize];
[
"Offset of field: AnvilGameDate::size",
][::core::mem::offset_of!(AnvilGameDate, size) - 0usize];
[
"Offset of field: AnvilGameDate::year",
][::core::mem::offset_of!(AnvilGameDate, year) - 4usize];
[
"Offset of field: AnvilGameDate::month",
][::core::mem::offset_of!(AnvilGameDate, month) - 8usize];
[
"Offset of field: AnvilGameDate::day",
][::core::mem::offset_of!(AnvilGameDate, day) - 12usize];
[
"Offset of field: AnvilGameDate::session",
][::core::mem::offset_of!(AnvilGameDate, session) - 16usize];
};
pub type AnvilGameWork = ::core::option::Option<
unsafe extern "C" fn(context: *mut core::ffi::c_void),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameService {
pub size: u32,
pub ready: ::core::option::Option<unsafe extern "C" fn() -> core::ffi::c_int>,
pub main_thread_id: ::core::option::Option<unsafe extern "C" fn() -> u32>,
pub frame_number: ::core::option::Option<unsafe extern "C" fn() -> u64>,
pub run_on_main_thread: ::core::option::Option<
unsafe extern "C" fn(
work: AnvilGameWork,
context: *mut core::ffi::c_void,
) -> AnvilResult,
>,
pub session: ::core::option::Option<
unsafe extern "C" fn(out: *mut AnvilGameSession) -> core::ffi::c_int,
>,
pub date: ::core::option::Option<
unsafe extern "C" fn(out: *mut AnvilGameDate) -> core::ffi::c_int,
>,
pub main_menu: ::core::option::Option<unsafe extern "C" fn() -> core::ffi::c_int>,
pub out_of_sync: ::core::option::Option<unsafe extern "C" fn() -> u32>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameService"][::core::mem::size_of::<AnvilGameService>() - 72usize];
[
"Alignment of AnvilGameService",
][::core::mem::align_of::<AnvilGameService>() - 8usize];
[
"Offset of field: AnvilGameService::size",
][::core::mem::offset_of!(AnvilGameService, size) - 0usize];
[
"Offset of field: AnvilGameService::ready",
][::core::mem::offset_of!(AnvilGameService, ready) - 8usize];
[
"Offset of field: AnvilGameService::main_thread_id",
][::core::mem::offset_of!(AnvilGameService, main_thread_id) - 16usize];
[
"Offset of field: AnvilGameService::frame_number",
][::core::mem::offset_of!(AnvilGameService, frame_number) - 24usize];
[
"Offset of field: AnvilGameService::run_on_main_thread",
][::core::mem::offset_of!(AnvilGameService, run_on_main_thread) - 32usize];
[
"Offset of field: AnvilGameService::session",
][::core::mem::offset_of!(AnvilGameService, session) - 40usize];
[
"Offset of field: AnvilGameService::date",
][::core::mem::offset_of!(AnvilGameService, date) - 48usize];
[
"Offset of field: AnvilGameService::main_menu",
][::core::mem::offset_of!(AnvilGameService, main_menu) - 56usize];
[
"Offset of field: AnvilGameService::out_of_sync",
][::core::mem::offset_of!(AnvilGameService, out_of_sync) - 64usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameOosChange {
pub size: u32,
pub flags: u32,
pub previous: u32,
pub reserved: u32,
pub session: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilGameOosChange",
][::core::mem::size_of::<AnvilGameOosChange>() - 24usize];
[
"Alignment of AnvilGameOosChange",
][::core::mem::align_of::<AnvilGameOosChange>() - 8usize];
[
"Offset of field: AnvilGameOosChange::size",
][::core::mem::offset_of!(AnvilGameOosChange, size) - 0usize];
[
"Offset of field: AnvilGameOosChange::flags",
][::core::mem::offset_of!(AnvilGameOosChange, flags) - 4usize];
[
"Offset of field: AnvilGameOosChange::previous",
][::core::mem::offset_of!(AnvilGameOosChange, previous) - 8usize];
[
"Offset of field: AnvilGameOosChange::reserved",
][::core::mem::offset_of!(AnvilGameOosChange, reserved) - 12usize];
[
"Offset of field: AnvilGameOosChange::session",
][::core::mem::offset_of!(AnvilGameOosChange, session) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameTag {
pub text: [core::ffi::c_char; 4usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameTag"][::core::mem::size_of::<AnvilGameTag>() - 4usize];
["Alignment of AnvilGameTag"][::core::mem::align_of::<AnvilGameTag>() - 1usize];
[
"Offset of field: AnvilGameTag::text",
][::core::mem::offset_of!(AnvilGameTag, text) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameDateChange {
pub size: u32,
pub days: u32,
pub date: AnvilGameDate,
pub previous: AnvilGameDate,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilGameDateChange",
][::core::mem::size_of::<AnvilGameDateChange>() - 56usize];
[
"Alignment of AnvilGameDateChange",
][::core::mem::align_of::<AnvilGameDateChange>() - 8usize];
[
"Offset of field: AnvilGameDateChange::size",
][::core::mem::offset_of!(AnvilGameDateChange, size) - 0usize];
[
"Offset of field: AnvilGameDateChange::days",
][::core::mem::offset_of!(AnvilGameDateChange, days) - 4usize];
[
"Offset of field: AnvilGameDateChange::date",
][::core::mem::offset_of!(AnvilGameDateChange, date) - 8usize];
[
"Offset of field: AnvilGameDateChange::previous",
][::core::mem::offset_of!(AnvilGameDateChange, previous) - 32usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGamePlayerChange {
pub size: u32,
pub tag: AnvilGameTag,
pub previous: AnvilGameTag,
pub session: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilGamePlayerChange",
][::core::mem::size_of::<AnvilGamePlayerChange>() - 24usize];
[
"Alignment of AnvilGamePlayerChange",
][::core::mem::align_of::<AnvilGamePlayerChange>() - 8usize];
[
"Offset of field: AnvilGamePlayerChange::size",
][::core::mem::offset_of!(AnvilGamePlayerChange, size) - 0usize];
[
"Offset of field: AnvilGamePlayerChange::tag",
][::core::mem::offset_of!(AnvilGamePlayerChange, tag) - 4usize];
[
"Offset of field: AnvilGamePlayerChange::previous",
][::core::mem::offset_of!(AnvilGamePlayerChange, previous) - 8usize];
[
"Offset of field: AnvilGamePlayerChange::session",
][::core::mem::offset_of!(AnvilGamePlayerChange, session) - 16usize];
};
pub const ANVIL_GAME_WAR_STARTED: AnvilGameWarChangeKind = 1;
pub const ANVIL_GAME_WAR_ENDED: AnvilGameWarChangeKind = 2;
pub type AnvilGameWarChangeKind = core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameWarChange {
pub size: u32,
pub change: u32,
pub war: u64,
pub attacker: AnvilGameTag,
pub defender: AnvilGameTag,
pub name: *const core::ffi::c_char,
pub session: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilGameWarChange",
][::core::mem::size_of::<AnvilGameWarChange>() - 40usize];
[
"Alignment of AnvilGameWarChange",
][::core::mem::align_of::<AnvilGameWarChange>() - 8usize];
[
"Offset of field: AnvilGameWarChange::size",
][::core::mem::offset_of!(AnvilGameWarChange, size) - 0usize];
[
"Offset of field: AnvilGameWarChange::change",
][::core::mem::offset_of!(AnvilGameWarChange, change) - 4usize];
[
"Offset of field: AnvilGameWarChange::war",
][::core::mem::offset_of!(AnvilGameWarChange, war) - 8usize];
[
"Offset of field: AnvilGameWarChange::attacker",
][::core::mem::offset_of!(AnvilGameWarChange, attacker) - 16usize];
[
"Offset of field: AnvilGameWarChange::defender",
][::core::mem::offset_of!(AnvilGameWarChange, defender) - 20usize];
[
"Offset of field: AnvilGameWarChange::name",
][::core::mem::offset_of!(AnvilGameWarChange, name) - 24usize];
[
"Offset of field: AnvilGameWarChange::session",
][::core::mem::offset_of!(AnvilGameWarChange, session) - 32usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameProvince {
pub size: u32,
pub id: i32,
pub owner: AnvilGameTag,
pub controller: AnvilGameTag,
pub base_tax: i32,
pub base_production: i32,
pub base_manpower: i32,
pub flags: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameProvince"][::core::mem::size_of::<AnvilGameProvince>() - 32usize];
[
"Alignment of AnvilGameProvince",
][::core::mem::align_of::<AnvilGameProvince>() - 4usize];
[
"Offset of field: AnvilGameProvince::size",
][::core::mem::offset_of!(AnvilGameProvince, size) - 0usize];
[
"Offset of field: AnvilGameProvince::id",
][::core::mem::offset_of!(AnvilGameProvince, id) - 4usize];
[
"Offset of field: AnvilGameProvince::owner",
][::core::mem::offset_of!(AnvilGameProvince, owner) - 8usize];
[
"Offset of field: AnvilGameProvince::controller",
][::core::mem::offset_of!(AnvilGameProvince, controller) - 12usize];
[
"Offset of field: AnvilGameProvince::base_tax",
][::core::mem::offset_of!(AnvilGameProvince, base_tax) - 16usize];
[
"Offset of field: AnvilGameProvince::base_production",
][::core::mem::offset_of!(AnvilGameProvince, base_production) - 20usize];
[
"Offset of field: AnvilGameProvince::base_manpower",
][::core::mem::offset_of!(AnvilGameProvince, base_manpower) - 24usize];
[
"Offset of field: AnvilGameProvince::flags",
][::core::mem::offset_of!(AnvilGameProvince, flags) - 28usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameCountry {
pub size: u32,
pub tag: AnvilGameTag,
pub capital: i32,
pub province_count: i32,
pub flags: u32,
pub values: u32,
pub treasury: i32,
pub stability: i32,
pub prestige: i32,
pub manpower: i32,
pub monthly_income: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameCountry"][::core::mem::size_of::<AnvilGameCountry>() - 44usize];
[
"Alignment of AnvilGameCountry",
][::core::mem::align_of::<AnvilGameCountry>() - 4usize];
[
"Offset of field: AnvilGameCountry::size",
][::core::mem::offset_of!(AnvilGameCountry, size) - 0usize];
[
"Offset of field: AnvilGameCountry::tag",
][::core::mem::offset_of!(AnvilGameCountry, tag) - 4usize];
[
"Offset of field: AnvilGameCountry::capital",
][::core::mem::offset_of!(AnvilGameCountry, capital) - 8usize];
[
"Offset of field: AnvilGameCountry::province_count",
][::core::mem::offset_of!(AnvilGameCountry, province_count) - 12usize];
[
"Offset of field: AnvilGameCountry::flags",
][::core::mem::offset_of!(AnvilGameCountry, flags) - 16usize];
[
"Offset of field: AnvilGameCountry::values",
][::core::mem::offset_of!(AnvilGameCountry, values) - 20usize];
[
"Offset of field: AnvilGameCountry::treasury",
][::core::mem::offset_of!(AnvilGameCountry, treasury) - 24usize];
[
"Offset of field: AnvilGameCountry::stability",
][::core::mem::offset_of!(AnvilGameCountry, stability) - 28usize];
[
"Offset of field: AnvilGameCountry::prestige",
][::core::mem::offset_of!(AnvilGameCountry, prestige) - 32usize];
[
"Offset of field: AnvilGameCountry::manpower",
][::core::mem::offset_of!(AnvilGameCountry, manpower) - 36usize];
[
"Offset of field: AnvilGameCountry::monthly_income",
][::core::mem::offset_of!(AnvilGameCountry, monthly_income) - 40usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameWar {
pub size: u32,
pub reserved: u32,
pub id: u64,
pub attacker: AnvilGameTag,
pub defender: AnvilGameTag,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameWar"][::core::mem::size_of::<AnvilGameWar>() - 24usize];
["Alignment of AnvilGameWar"][::core::mem::align_of::<AnvilGameWar>() - 8usize];
[
"Offset of field: AnvilGameWar::size",
][::core::mem::offset_of!(AnvilGameWar, size) - 0usize];
[
"Offset of field: AnvilGameWar::reserved",
][::core::mem::offset_of!(AnvilGameWar, reserved) - 4usize];
[
"Offset of field: AnvilGameWar::id",
][::core::mem::offset_of!(AnvilGameWar, id) - 8usize];
[
"Offset of field: AnvilGameWar::attacker",
][::core::mem::offset_of!(AnvilGameWar, attacker) - 16usize];
[
"Offset of field: AnvilGameWar::defender",
][::core::mem::offset_of!(AnvilGameWar, defender) - 20usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameUnit {
pub size: u32,
pub kind: u32,
pub id: u64,
pub country: AnvilGameTag,
pub location: i32,
pub mission: i32,
pub subunits: u32,
pub strength: i32,
pub reserved: u32,
pub leader: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameUnit"][::core::mem::size_of::<AnvilGameUnit>() - 48usize];
["Alignment of AnvilGameUnit"][::core::mem::align_of::<AnvilGameUnit>() - 8usize];
[
"Offset of field: AnvilGameUnit::size",
][::core::mem::offset_of!(AnvilGameUnit, size) - 0usize];
[
"Offset of field: AnvilGameUnit::kind",
][::core::mem::offset_of!(AnvilGameUnit, kind) - 4usize];
[
"Offset of field: AnvilGameUnit::id",
][::core::mem::offset_of!(AnvilGameUnit, id) - 8usize];
[
"Offset of field: AnvilGameUnit::country",
][::core::mem::offset_of!(AnvilGameUnit, country) - 16usize];
[
"Offset of field: AnvilGameUnit::location",
][::core::mem::offset_of!(AnvilGameUnit, location) - 20usize];
[
"Offset of field: AnvilGameUnit::mission",
][::core::mem::offset_of!(AnvilGameUnit, mission) - 24usize];
[
"Offset of field: AnvilGameUnit::subunits",
][::core::mem::offset_of!(AnvilGameUnit, subunits) - 28usize];
[
"Offset of field: AnvilGameUnit::strength",
][::core::mem::offset_of!(AnvilGameUnit, strength) - 32usize];
[
"Offset of field: AnvilGameUnit::reserved",
][::core::mem::offset_of!(AnvilGameUnit, reserved) - 36usize];
[
"Offset of field: AnvilGameUnit::leader",
][::core::mem::offset_of!(AnvilGameUnit, leader) - 40usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameUnitRef {
pub id: u64,
pub country: AnvilGameTag,
pub kind: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilGameUnitRef"][::core::mem::size_of::<AnvilGameUnitRef>() - 16usize];
[
"Alignment of AnvilGameUnitRef",
][::core::mem::align_of::<AnvilGameUnitRef>() - 8usize];
[
"Offset of field: AnvilGameUnitRef::id",
][::core::mem::offset_of!(AnvilGameUnitRef, id) - 0usize];
[
"Offset of field: AnvilGameUnitRef::country",
][::core::mem::offset_of!(AnvilGameUnitRef, country) - 8usize];
[
"Offset of field: AnvilGameUnitRef::kind",
][::core::mem::offset_of!(AnvilGameUnitRef, kind) - 12usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilGameWorldService {
pub size: u32,
pub player: ::core::option::Option<
unsafe extern "C" fn(out: *mut AnvilGameTag) -> AnvilResult,
>,
pub province_limit: ::core::option::Option<unsafe extern "C" fn() -> i32>,
pub province: ::core::option::Option<
unsafe extern "C" fn(id: i32, out: *mut AnvilGameProvince) -> AnvilResult,
>,
pub province_name: ::core::option::Option<
unsafe extern "C" fn(
id: i32,
utf8: *mut core::ffi::c_char,
capacity: u32,
length: *mut u32,
) -> AnvilResult,
>,
pub province_cores: ::core::option::Option<
unsafe extern "C" fn(
id: i32,
out: *mut AnvilGameTag,
capacity: u32,
count: *mut u32,
) -> AnvilResult,
>,
pub country: ::core::option::Option<
unsafe extern "C" fn(
tag: *const core::ffi::c_char,
out: *mut AnvilGameCountry,
) -> AnvilResult,
>,
pub country_provinces: ::core::option::Option<
unsafe extern "C" fn(
tag: *const core::ffi::c_char,
ids: *mut i32,
capacity: u32,
count: *mut u32,
) -> AnvilResult,
>,
pub war_ids: ::core::option::Option<
unsafe extern "C" fn(
ids: *mut u64,
capacity: u32,
count: *mut u32,
) -> AnvilResult,
>,
pub war: ::core::option::Option<
unsafe extern "C" fn(id: u64, out: *mut AnvilGameWar) -> AnvilResult,
>,
pub war_name: ::core::option::Option<
unsafe extern "C" fn(
id: u64,
utf8: *mut core::ffi::c_char,
capacity: u32,
length: *mut u32,
) -> AnvilResult,
>,
pub war_side: ::core::option::Option<
unsafe extern "C" fn(
id: u64,
side: u32,
out: *mut AnvilGameTag,
capacity: u32,
count: *mut u32,
) -> AnvilResult,
>,
pub modifier_id: ::core::option::Option<
unsafe extern "C" fn(key: *const core::ffi::c_char, id: *mut i32) -> AnvilResult,
>,
pub country_modifier: ::core::option::Option<
unsafe extern "C" fn(
tag: *const core::ffi::c_char,
id: i32,
value: *mut i32,
) -> AnvilResult,
>,
pub province_modifier: ::core::option::Option<
unsafe extern "C" fn(province: i32, id: i32, value: *mut i32) -> AnvilResult,
>,
pub country_units: ::core::option::Option<
unsafe extern "C" fn(
tag: *const core::ffi::c_char,
ids: *mut u64,
capacity: u32,
count: *mut u32,
) -> AnvilResult,
>,
pub unit: ::core::option::Option<
unsafe extern "C" fn(
tag: *const core::ffi::c_char,
id: u64,
out: *mut AnvilGameUnit,
) -> AnvilResult,
>,
pub unit_name: ::core::option::Option<
unsafe extern "C" fn(
tag: *const core::ffi::c_char,
id: u64,
utf8: *mut core::ffi::c_char,
capacity: u32,
length: *mut u32,
) -> AnvilResult,
>,
pub unit_leader_name: ::core::option::Option<
unsafe extern "C" fn(
tag: *const core::ffi::c_char,
id: u64,
utf8: *mut core::ffi::c_char,
capacity: u32,
length: *mut u32,
) -> AnvilResult,
>,
pub selected_units: ::core::option::Option<
unsafe extern "C" fn(
out: *mut AnvilGameUnitRef,
capacity: u32,
count: *mut u32,
) -> AnvilResult,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilGameWorldService",
][::core::mem::size_of::<AnvilGameWorldService>() - 160usize];
[
"Alignment of AnvilGameWorldService",
][::core::mem::align_of::<AnvilGameWorldService>() - 8usize];
[
"Offset of field: AnvilGameWorldService::size",
][::core::mem::offset_of!(AnvilGameWorldService, size) - 0usize];
[
"Offset of field: AnvilGameWorldService::player",
][::core::mem::offset_of!(AnvilGameWorldService, player) - 8usize];
[
"Offset of field: AnvilGameWorldService::province_limit",
][::core::mem::offset_of!(AnvilGameWorldService, province_limit) - 16usize];
[
"Offset of field: AnvilGameWorldService::province",
][::core::mem::offset_of!(AnvilGameWorldService, province) - 24usize];
[
"Offset of field: AnvilGameWorldService::province_name",
][::core::mem::offset_of!(AnvilGameWorldService, province_name) - 32usize];
[
"Offset of field: AnvilGameWorldService::province_cores",
][::core::mem::offset_of!(AnvilGameWorldService, province_cores) - 40usize];
[
"Offset of field: AnvilGameWorldService::country",
][::core::mem::offset_of!(AnvilGameWorldService, country) - 48usize];
[
"Offset of field: AnvilGameWorldService::country_provinces",
][::core::mem::offset_of!(AnvilGameWorldService, country_provinces) - 56usize];
[
"Offset of field: AnvilGameWorldService::war_ids",
][::core::mem::offset_of!(AnvilGameWorldService, war_ids) - 64usize];
[
"Offset of field: AnvilGameWorldService::war",
][::core::mem::offset_of!(AnvilGameWorldService, war) - 72usize];
[
"Offset of field: AnvilGameWorldService::war_name",
][::core::mem::offset_of!(AnvilGameWorldService, war_name) - 80usize];
[
"Offset of field: AnvilGameWorldService::war_side",
][::core::mem::offset_of!(AnvilGameWorldService, war_side) - 88usize];
[
"Offset of field: AnvilGameWorldService::modifier_id",
][::core::mem::offset_of!(AnvilGameWorldService, modifier_id) - 96usize];
[
"Offset of field: AnvilGameWorldService::country_modifier",
][::core::mem::offset_of!(AnvilGameWorldService, country_modifier) - 104usize];
[
"Offset of field: AnvilGameWorldService::province_modifier",
][::core::mem::offset_of!(AnvilGameWorldService, province_modifier) - 112usize];
[
"Offset of field: AnvilGameWorldService::country_units",
][::core::mem::offset_of!(AnvilGameWorldService, country_units) - 120usize];
[
"Offset of field: AnvilGameWorldService::unit",
][::core::mem::offset_of!(AnvilGameWorldService, unit) - 128usize];
[
"Offset of field: AnvilGameWorldService::unit_name",
][::core::mem::offset_of!(AnvilGameWorldService, unit_name) - 136usize];
[
"Offset of field: AnvilGameWorldService::unit_leader_name",
][::core::mem::offset_of!(AnvilGameWorldService, unit_leader_name) - 144usize];
[
"Offset of field: AnvilGameWorldService::selected_units",
][::core::mem::offset_of!(AnvilGameWorldService, selected_units) - 152usize];
};
#[repr(C)]
#[derive(Debug)]
pub struct AnvilPanel {
_unused: [u8; 0],
}
pub const ANVIL_PANEL_TEXT: AnvilPanelRowKind = 1;
pub const ANVIL_PANEL_BUTTON: AnvilPanelRowKind = 2;
pub const ANVIL_PANEL_SEPARATOR: AnvilPanelRowKind = 3;
pub type AnvilPanelRowKind = core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilPanelRow {
pub kind: u32,
pub reserved: u32,
pub label: *const core::ffi::c_char,
pub value: *const core::ffi::c_char,
pub id: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilPanelRow"][::core::mem::size_of::<AnvilPanelRow>() - 32usize];
["Alignment of AnvilPanelRow"][::core::mem::align_of::<AnvilPanelRow>() - 8usize];
[
"Offset of field: AnvilPanelRow::kind",
][::core::mem::offset_of!(AnvilPanelRow, kind) - 0usize];
[
"Offset of field: AnvilPanelRow::reserved",
][::core::mem::offset_of!(AnvilPanelRow, reserved) - 4usize];
[
"Offset of field: AnvilPanelRow::label",
][::core::mem::offset_of!(AnvilPanelRow, label) - 8usize];
[
"Offset of field: AnvilPanelRow::value",
][::core::mem::offset_of!(AnvilPanelRow, value) - 16usize];
[
"Offset of field: AnvilPanelRow::id",
][::core::mem::offset_of!(AnvilPanelRow, id) - 24usize];
};
pub type AnvilPanelClick = ::core::option::Option<
unsafe extern "C" fn(context: *mut core::ffi::c_void, id: u64),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilPanelService {
pub size: u32,
pub create: ::core::option::Option<
unsafe extern "C" fn(
title: *const core::ffi::c_char,
out: *mut *mut AnvilPanel,
) -> AnvilResult,
>,
pub set_rows: ::core::option::Option<
unsafe extern "C" fn(
panel: *mut AnvilPanel,
rows: *const AnvilPanelRow,
count: u32,
row_size: u32,
) -> AnvilResult,
>,
pub on_click: ::core::option::Option<
unsafe extern "C" fn(
panel: *mut AnvilPanel,
click: AnvilPanelClick,
context: *mut core::ffi::c_void,
) -> AnvilResult,
>,
pub show: ::core::option::Option<
unsafe extern "C" fn(
panel: *mut AnvilPanel,
shown: core::ffi::c_int,
) -> AnvilResult,
>,
pub shown: ::core::option::Option<
unsafe extern "C" fn(panel: *const AnvilPanel) -> core::ffi::c_int,
>,
pub language: ::core::option::Option<
unsafe extern "C" fn() -> *const core::ffi::c_char,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilPanelService"][::core::mem::size_of::<AnvilPanelService>() - 56usize];
[
"Alignment of AnvilPanelService",
][::core::mem::align_of::<AnvilPanelService>() - 8usize];
[
"Offset of field: AnvilPanelService::size",
][::core::mem::offset_of!(AnvilPanelService, size) - 0usize];
[
"Offset of field: AnvilPanelService::create",
][::core::mem::offset_of!(AnvilPanelService, create) - 8usize];
[
"Offset of field: AnvilPanelService::set_rows",
][::core::mem::offset_of!(AnvilPanelService, set_rows) - 16usize];
[
"Offset of field: AnvilPanelService::on_click",
][::core::mem::offset_of!(AnvilPanelService, on_click) - 24usize];
[
"Offset of field: AnvilPanelService::show",
][::core::mem::offset_of!(AnvilPanelService, show) - 32usize];
[
"Offset of field: AnvilPanelService::shown",
][::core::mem::offset_of!(AnvilPanelService, shown) - 40usize];
[
"Offset of field: AnvilPanelService::language",
][::core::mem::offset_of!(AnvilPanelService, language) - 48usize];
};
pub const ANVIL_BENCHMARK_INT: AnvilBenchmarkKind = 1;
pub const ANVIL_BENCHMARK_NUMBER: AnvilBenchmarkKind = 2;
pub const ANVIL_BENCHMARK_ENUM: AnvilBenchmarkKind = 3;
pub const ANVIL_BENCHMARK_FLAG: AnvilBenchmarkKind = 4;
pub type AnvilBenchmarkKind = core::ffi::c_int;
pub const ANVIL_BENCHMARK_UNIT_NONE: AnvilBenchmarkUnit = 0;
pub const ANVIL_BENCHMARK_UNIT_MS: AnvilBenchmarkUnit = 1;
pub const ANVIL_BENCHMARK_UNIT_COUNT: AnvilBenchmarkUnit = 2;
pub const ANVIL_BENCHMARK_UNIT_BYTES: AnvilBenchmarkUnit = 3;
pub const ANVIL_BENCHMARK_UNIT_MB: AnvilBenchmarkUnit = 4;
pub const ANVIL_BENCHMARK_UNIT_PERCENT: AnvilBenchmarkUnit = 5;
pub type AnvilBenchmarkUnit = core::ffi::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilBenchmarkField {
pub name: *const core::ffi::c_char,
pub kind: u32,
pub unit: u32,
pub label: *const core::ffi::c_char,
pub options: *const *const core::ffi::c_char,
pub option_count: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilBenchmarkField",
][::core::mem::size_of::<AnvilBenchmarkField>() - 40usize];
[
"Alignment of AnvilBenchmarkField",
][::core::mem::align_of::<AnvilBenchmarkField>() - 8usize];
[
"Offset of field: AnvilBenchmarkField::name",
][::core::mem::offset_of!(AnvilBenchmarkField, name) - 0usize];
[
"Offset of field: AnvilBenchmarkField::kind",
][::core::mem::offset_of!(AnvilBenchmarkField, kind) - 8usize];
[
"Offset of field: AnvilBenchmarkField::unit",
][::core::mem::offset_of!(AnvilBenchmarkField, unit) - 12usize];
[
"Offset of field: AnvilBenchmarkField::label",
][::core::mem::offset_of!(AnvilBenchmarkField, label) - 16usize];
[
"Offset of field: AnvilBenchmarkField::options",
][::core::mem::offset_of!(AnvilBenchmarkField, options) - 24usize];
[
"Offset of field: AnvilBenchmarkField::option_count",
][::core::mem::offset_of!(AnvilBenchmarkField, option_count) - 32usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilBenchmarkService {
pub size: u32,
pub active: ::core::option::Option<unsafe extern "C" fn() -> core::ffi::c_int>,
pub declare: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
fields: *const AnvilBenchmarkField,
count: u32,
) -> AnvilResult,
>,
pub set_int: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
field: *const core::ffi::c_char,
value: i64,
) -> AnvilResult,
>,
pub set_number: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
field: *const core::ffi::c_char,
value: f64,
) -> AnvilResult,
>,
pub set_enum: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
field: *const core::ffi::c_char,
option: *const core::ffi::c_char,
) -> AnvilResult,
>,
pub set_flag: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
field: *const core::ffi::c_char,
value: core::ffi::c_int,
) -> AnvilResult,
>,
pub done: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin) -> AnvilResult,
>,
pub learning: ::core::option::Option<
unsafe extern "C" fn(
self_: *mut AnvilPlugin,
reason: *const core::ffi::c_char,
) -> AnvilResult,
>,
pub open_cost: ::core::option::Option<
unsafe extern "C" fn(self_: *mut AnvilPlugin, files: u64, ms: f64) -> AnvilResult,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilBenchmarkService",
][::core::mem::size_of::<AnvilBenchmarkService>() - 80usize];
[
"Alignment of AnvilBenchmarkService",
][::core::mem::align_of::<AnvilBenchmarkService>() - 8usize];
[
"Offset of field: AnvilBenchmarkService::size",
][::core::mem::offset_of!(AnvilBenchmarkService, size) - 0usize];
[
"Offset of field: AnvilBenchmarkService::active",
][::core::mem::offset_of!(AnvilBenchmarkService, active) - 8usize];
[
"Offset of field: AnvilBenchmarkService::declare",
][::core::mem::offset_of!(AnvilBenchmarkService, declare) - 16usize];
[
"Offset of field: AnvilBenchmarkService::set_int",
][::core::mem::offset_of!(AnvilBenchmarkService, set_int) - 24usize];
[
"Offset of field: AnvilBenchmarkService::set_number",
][::core::mem::offset_of!(AnvilBenchmarkService, set_number) - 32usize];
[
"Offset of field: AnvilBenchmarkService::set_enum",
][::core::mem::offset_of!(AnvilBenchmarkService, set_enum) - 40usize];
[
"Offset of field: AnvilBenchmarkService::set_flag",
][::core::mem::offset_of!(AnvilBenchmarkService, set_flag) - 48usize];
[
"Offset of field: AnvilBenchmarkService::done",
][::core::mem::offset_of!(AnvilBenchmarkService, done) - 56usize];
[
"Offset of field: AnvilBenchmarkService::learning",
][::core::mem::offset_of!(AnvilBenchmarkService, learning) - 64usize];
[
"Offset of field: AnvilBenchmarkService::open_cost",
][::core::mem::offset_of!(AnvilBenchmarkService, open_cost) - 72usize];
};
pub const ANVIL_MAP_TAB_DEFAULT: AnvilMapTab = 0;
pub const ANVIL_MAP_TAB_1: AnvilMapTab = 1;
pub const ANVIL_MAP_TAB_2: AnvilMapTab = 2;
pub const ANVIL_MAP_TAB_3: AnvilMapTab = 3;
pub const ANVIL_MAP_TAB_4: AnvilMapTab = 4;
pub type AnvilMapTab = core::ffi::c_int;
#[repr(C)]
#[derive(Debug)]
pub struct AnvilMapMode {
_unused: [u8; 0],
}
pub type AnvilMapDescribe = ::core::option::Option<
unsafe extern "C" fn(
context: *mut core::ffi::c_void,
mode: *const AnvilMapMode,
province: i32,
text: *mut core::ffi::c_char,
capacity: usize,
) -> usize,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilMapModeInfo {
pub size: u32,
pub tab: u32,
pub id: *const core::ffi::c_char,
pub label: *const core::ffi::c_char,
pub description: *const core::ffi::c_char,
pub sprite: *const core::ffi::c_char,
pub describe: AnvilMapDescribe,
pub context: *mut core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of AnvilMapModeInfo"][::core::mem::size_of::<AnvilMapModeInfo>() - 56usize];
[
"Alignment of AnvilMapModeInfo",
][::core::mem::align_of::<AnvilMapModeInfo>() - 8usize];
[
"Offset of field: AnvilMapModeInfo::size",
][::core::mem::offset_of!(AnvilMapModeInfo, size) - 0usize];
[
"Offset of field: AnvilMapModeInfo::tab",
][::core::mem::offset_of!(AnvilMapModeInfo, tab) - 4usize];
[
"Offset of field: AnvilMapModeInfo::id",
][::core::mem::offset_of!(AnvilMapModeInfo, id) - 8usize];
[
"Offset of field: AnvilMapModeInfo::label",
][::core::mem::offset_of!(AnvilMapModeInfo, label) - 16usize];
[
"Offset of field: AnvilMapModeInfo::description",
][::core::mem::offset_of!(AnvilMapModeInfo, description) - 24usize];
[
"Offset of field: AnvilMapModeInfo::sprite",
][::core::mem::offset_of!(AnvilMapModeInfo, sprite) - 32usize];
[
"Offset of field: AnvilMapModeInfo::describe",
][::core::mem::offset_of!(AnvilMapModeInfo, describe) - 40usize];
[
"Offset of field: AnvilMapModeInfo::context",
][::core::mem::offset_of!(AnvilMapModeInfo, context) - 48usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilMapModeChange {
pub size: u32,
pub reserved: u32,
pub mode: *const AnvilMapMode,
pub id: *const core::ffi::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilMapModeChange",
][::core::mem::size_of::<AnvilMapModeChange>() - 24usize];
[
"Alignment of AnvilMapModeChange",
][::core::mem::align_of::<AnvilMapModeChange>() - 8usize];
[
"Offset of field: AnvilMapModeChange::size",
][::core::mem::offset_of!(AnvilMapModeChange, size) - 0usize];
[
"Offset of field: AnvilMapModeChange::reserved",
][::core::mem::offset_of!(AnvilMapModeChange, reserved) - 4usize];
[
"Offset of field: AnvilMapModeChange::mode",
][::core::mem::offset_of!(AnvilMapModeChange, mode) - 8usize];
[
"Offset of field: AnvilMapModeChange::id",
][::core::mem::offset_of!(AnvilMapModeChange, id) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct AnvilMapModesService {
pub size: u32,
pub register_mode: ::core::option::Option<
unsafe extern "C" fn(
info: *const AnvilMapModeInfo,
out: *mut *const AnvilMapMode,
) -> AnvilResult,
>,
pub set_colors: ::core::option::Option<
unsafe extern "C" fn(
mode: *const AnvilMapMode,
colors: *const u32,
count: u32,
) -> AnvilResult,
>,
pub mode_id: ::core::option::Option<
unsafe extern "C" fn(number: i32) -> *const core::ffi::c_char,
>,
pub shown: ::core::option::Option<unsafe extern "C" fn() -> *const AnvilMapMode>,
pub id: ::core::option::Option<
unsafe extern "C" fn(mode: *const AnvilMapMode) -> *const core::ffi::c_char,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
[
"Size of AnvilMapModesService",
][::core::mem::size_of::<AnvilMapModesService>() - 48usize];
[
"Alignment of AnvilMapModesService",
][::core::mem::align_of::<AnvilMapModesService>() - 8usize];
[
"Offset of field: AnvilMapModesService::size",
][::core::mem::offset_of!(AnvilMapModesService, size) - 0usize];
[
"Offset of field: AnvilMapModesService::register_mode",
][::core::mem::offset_of!(AnvilMapModesService, register_mode) - 8usize];
[
"Offset of field: AnvilMapModesService::set_colors",
][::core::mem::offset_of!(AnvilMapModesService, set_colors) - 16usize];
[
"Offset of field: AnvilMapModesService::mode_id",
][::core::mem::offset_of!(AnvilMapModesService, mode_id) - 24usize];
[
"Offset of field: AnvilMapModesService::shown",
][::core::mem::offset_of!(AnvilMapModesService, shown) - 32usize];
[
"Offset of field: AnvilMapModesService::id",
][::core::mem::offset_of!(AnvilMapModesService, id) - 40usize];
};