Method generate_reducer_file

crates/codegen/src/unrealcpp.rs:424–620

(&self, module: &ModuleDef, reducer: &ReducerDef)

    }

    fn generate_reducer_file(&self, module: &ModuleDef, reducer: &ReducerDef) -> OutputFile {
        let module_prefix = self.module_prefix;
        let reducer_pascal = reducer.name.deref().to_case(Case::Pascal);
        let pascal = format!("{module_prefix}{reducer_pascal}");

        // Collect includes for parameter types
        let mut includes = HashSet::<String>::new();
        for (_param_name, param_type) in &reducer.params_for_generate.elements {
            collect_includes_for_type(self.module_prefix, module, param_type, &mut includes, self.module_name);
        }

        // Add {module_prefix}ReducerBase.g.h for U{module_prefix}ReducerBase definition
        includes.insert(format!("ModuleBindings/{module_prefix}ReducerBase.g.h"));

        // Convert to sorted vector
        let mut include_vec: Vec<String> = includes.into_iter().collect();
        include_vec.sort();

        // Convert to string references
        let include_refs: Vec<&str> = include_vec.iter().map(|s| s.as_str()).collect();

        let mut header = UnrealCppAutogen::new(&include_refs, &pascal, false);

        let args_struct = format!("F{pascal}Args");

        // Generate reducer arguments struct
        writeln!(header, "// Reducer arguments struct for {pascal}");
        writeln!(header, "USTRUCT(BlueprintType)");
        writeln!(header, "struct {} {args_struct}", self.get_api_macro());
        writeln!(header, "{{");
        writeln!(header, "    GENERATED_BODY()");
        writeln!(header);

        // Generate properties for each parameter
        for (param_name, param_type) in &reducer.params_for_generate.elements {
            let param_pascal = param_name.deref().to_case(Case::Pascal);
            let type_str = cpp_ty_fmt_with_module(self.module_prefix, module, param_type, self.module_name).to_string();
            let init_str = cpp_ty_init_fmt_impl(self.module_prefix, module, param_type);
            let field_decl = format!("{type_str} {param_pascal}{init_str}");

            // Check if the type is blueprintable
            if is_blueprintable(module, param_type) {
                writeln!(header, "    UPROPERTY(BlueprintReadWrite, Category=\"SpacetimeDB\")");
            } else {
                // Add comment explaining why the field isn't exposed as UPROPERTY
                writeln!(
                    header,
                    "    // NOTE: {type_str} field not exposed to Blueprint due to non-blueprintable elements"
                );
            }
            writeln!(header, "    {field_decl};");
            writeln!(header);
        }

        // Generate default constructor
        writeln!(header, "    {args_struct}() = default;");
        writeln!(header);