process multiple out_elems

isotest/bits/el_stone.v

@@ -14,6 +14,7 @@ fn crush_stone_bit() {
 
 }
 
+/*
 // stone -> crushed stone
 // XXX turn stone object into crushed stone object
 // XXX all volume
@@ -44,6 +45,7 @@ fn crush_stone_object2(ob &Object) {
 
 	prc.process(ob)
 }
+*/
 
 // XXX should be registered on facrory
 // XXX rename to stole_crush_object() ?
@@ -60,16 +62,20 @@ fn stone_crush_object_part(ob &Object) {
 		mut prc := new_processor()
 		prc.name = "crushed_stone"
 		prc.in_elem = bits_ctx.elem_lib["stone"]
-		prc.out_elem = bits_ctx.elem_lib["crushed_stone"]
-		prc.output_factor = 0.6
-		prc.req_electricity = true
-		prc.req_power = 1000
+
+		mut rec := new_processor_out_elem_rec()
+		rec.out_elem = bits_ctx.elem_lib["crushed_stone"]
+		rec.output_factor = 0.6
+		rec.req_electricity = true
+		rec.req_power = 1000
+
+		prc.out_elems << rec
 
 		// Checks
 		if isnil(prc.in_elem) {
 			panic("bad in_elem")
 		}
-		if isnil(prc.out_elem) {
+		if prc.out_elems.len < 1 {
 			panic("bad out_elem")
 		}
 

isotest/bits/main.v

@@ -108,10 +108,10 @@ pub fn bits_main() {
 	mut prc := new_processor()
 	prc.name = "crushed_stone"
 	prc.in_elem = e4
-	prc.out_elem = e4
-	prc.output_factor = 0.6
-	prc.req_electricity = true
-	prc.req_power = 1000
+	//prc.out_elem = e4
+	//prc.output_factor = 0.6
+	//prc.req_electricity = true
+	//prc.req_power = 1000
 
 	// XXX
 	//println("prc: ${prc}")

isotest/bits/processor.v

@@ -1,13 +1,16 @@
 module bits
 
+// Out elem record/info
 // One to [Many]
-struct ProcessorOutputTableRecord {
+struct ProcessorOutElemRec {
 mut:
 	//out_elems map[string]&Elem
 	out_elem &Elem
 
 	output_factor f32
 
+	replaces_in_elem bool
+
 	cond_temp int
 	req_electricity bool
 	req_power int
@@ -15,14 +18,22 @@ mut:
 	req_water int
 }
 
+fn new_processor_out_elem_rec() &ProcessorOutElemRec {
+	r := &ProcessorOutElemRec{
+		out_elem: &Elem(0),
+	}
+	return r
+}
+
 // A convertor from one element to another
 struct Processor {
 mut:
 	name string
+	// Always one [One]
 	in_elem &Elem
 	//out_elem &Elem
-	// [One] to Many
-	out_elems []&ProcessorOutputTableRecord
+	// Always many [Many]
+	out_elems []&ProcessorOutElemRec
 	//out_elems_map map[string][]&ProcessorOutputTableRecord
 
 	//output_factor f32
@@ -37,7 +48,7 @@ mut:
 fn new_processor() &Processor {
 	p := &Processor{
 		in_elem: &Elem(0),
-		out_elem: &Elem(0),
+		//out_elem: &Elem(0),
 	}
 	return p
 }
@@ -45,39 +56,46 @@ fn new_processor() &Processor {
 fn (p &Processor) process(mut o Object) {
 	println("processor process")
 
-	println("in elem: $p.in_elem.name")
-	println("out elem: $p.out_elem.name")
-
-	new_elem := p.out_elem
-
-	if isnil(new_elem) {
-		println("error: new_elem cannot be nil")
-		exit(2)
-	}
-
 	mut processed := false
 
 	// Process all elems
-	mut elems_list := o.parts_info.elems_list()
-	for i, _ in elems_list {
-		mut me := elems_list[i]
+	mut pts_list := o.parts_info.elems_list()
+	for i, _ in pts_list {
+		mut pt := pts_list[i]
 
-		println("me.elem: $me.elem.name")
-		println("me.bits_size: $me.bits_size")
+		println("pt.elem: $pt.elem.name")
+		println("pt.bits_size: $pt.bits_size")
 
-		if me.elem.name == p.in_elem.name { // XXX fixme
-			println("process for ${me.elem}")
+		// XXX match, process part/elem
+		if pt.elem.name == p.in_elem.name { // XXX fixme
+			println("process for ${pt.elem.name}")
 
-			new_bits_size := int(me.bits_size * p.output_factor)
+			for out_elem_rec in p.out_elems {
 
-			println("new_elem: ${isnil(new_elem)}")
-			println("new_elem: $new_elem")
-			println("new_bits_size: $new_bits_size")
-			
-			me.elem = new_elem
-			me.bits_size = new_bits_size
+				println("in elem: $p.in_elem.name")
+				println("out elem: $out_elem_rec.out_elem.name")
 
-			processed = true
+				new_elem := out_elem_rec.out_elem
+
+				if isnil(new_elem) {
+					println("error: new_elem cannot be nil")
+					exit(2)
+				}
+
+				new_bits_size := int(pt.bits_size * out_elem_rec.output_factor)
+
+				println("new_elem: ${isnil(new_elem)}")
+				println("new_elem: $new_elem")
+				println("new_bits_size: $new_bits_size")
+
+				// Swap elems
+				if out_elem_rec.replaces_in_elem {
+					pt.elem = new_elem
+				}
+				pt.bits_size = new_bits_size
+
+				processed = true
+			}
 		}
 	}