coaljoe
/
auts
1
0
Fork 0
Code Releases Activity

Merge branch 'master' of https://gitlab.com/coaljoe/exp_auts into master

This commit is contained in:
coaljoe 2020-09-17 11:08:27 +03:00
parent 3f366e7de7 8415a255ec
commit efe115bd71
8 changed files with 228 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
isotest/bits/el_stone.v
View File

@ -1,5 +1,16 @@
module bits
// XXX specific processor
// XXX objects are data-driven ? fox flexibility?
struct StoneProcessor {
}
fn (p *StoneProcessor) crush_object_part(ob &Object) {
// XXX
stone_crush_object_part(ob)
}
// Create new stone bit object
fn new_stone_bit() &Object {
//println("new_stone_bit")
@ -14,6 +25,7 @@ fn crush_stone_bit() {
}
/*
// stone -> crushed stone
// XXX turn stone object into crushed stone object
// XXX all volume
@ -44,6 +56,7 @@ fn crush_stone_object2(ob &Object) {
prc.process(ob)
}
*/
// XXX should be registered on facrory
// XXX rename to stole_crush_object() ?
@ -60,22 +73,41 @@ 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.replaces_in_elem = true
rec.req_electricity = true
rec.req_power = 1000
prc.out_elems << rec
mut rec2 := new_processor_out_elem_rec()
rec2.out_elem = bits_ctx.elem_lib["sand"]
rec2.output_factor = 0.1
rec2.req_electricity = true
rec2.req_power = 1000
prc.out_elems << rec2
// 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")
}
prc.process(ob)
ret := prc.process(ob)
//prc.process_part(pt)
if ret.len > 0 {
println("ret len: ${ret.len}")
println("ret name: ${ret[0].elem.name}")
println("ret bits_size: ${ret[0].bits_size}")
}
//}
}

47
isotest/bits/elem_lib.v
View File

@ -22,4 +22,51 @@ fn init_elem_lib() {
bits_ctx.elem_lib["crushed_stone"] = el
}
{
mut el := new_elem()
el.name = "sand"
el.elem_type = .sand
el.density = 2000
bits_ctx.elem_lib["sand"] = el
}
{
mut el := new_elem()
el.name = "glass"
el.elem_type = .glass
el.density = 2200
bits_ctx.elem_lib["glass"] = el
}
{
mut el := new_elem()
el.name = "wood"
el.elem_type = .wood
el.density = 100
el.flameable = true
bits_ctx.elem_lib["wood"] = el
}
{
mut el := new_elem()
el.name = "water"
el.elem_type = .water
el.density = 10000
el.liquid = true
bits_ctx.elem_lib["water"] = el
}
{
mut el := new_elem()
el.name = "concrete"
el.elem_type = .concrete
el.density = 20000
bits_ctx.elem_lib["concrete"] = el
}
}

6
isotest/bits/elems.v
View File

@ -75,6 +75,12 @@ mut:
//generic_processors map[string]GenericProcessorI
//generic_processor0 &GenericProcessorI
//generic_processor0 &GenericCrusherProcessor
// XXX
//crush_object_part(ob &Object)
//processor_factories []GenericProcessorI
}
fn new_elem() &Elem {

2
isotest/bits/generic_processor.v
View File

@ -25,7 +25,7 @@ fn (gpc &GenericCrusherProcessor) process(ob &Object) {
//if ob.elem.name == "stone" {
//if ob.has_elem("stone") {
if ob.parts_info.has_elem_name("stone") {
if ob.mat_info.has_elem_name("stone") {
println("> create smaller stones")
//crush_stone_object(ob)

85
isotest/bits/main.v
View File

@ -1,5 +1,28 @@
module bits
fn test_wall() {
println("bits: test_wall()")
// Wall is 1x1x6 m in size
// Create wall
mut w := new_object()
w.name = "wall"
w.mat_info.add_elem_from_size(1, 1, 6, bits_ctx.elem_lib["stone"])
// Crush entire wall
mut gcp := new_generic_crusher_processor()
gcp.process(w)
println("w new bits volume: ${w.bits_volume()}")
println("w new volume: ${w.volume()}")
println("bits: done test_wall")
}
pub fn bits_main() {
println("bits: bits_main()")
@ -8,46 +31,6 @@ pub fn bits_main() {
init_elem_lib()
mut e := new_elem()
e.name = "wood"
e.elem_type = .wood
e.density = 100
e.flameable = true
_ = e
println("e: ${e}")
mut e2 := new_elem()
e2.name = "sand"
e2.elem_type = .sand
e2.density = 2000
println("e2: ${e2}")
mut e3 := new_elem()
e3.name = "glass"
e3.elem_type = .glass
e3.density = 2200
mut e4 := new_elem()
e4.name = "stone"
e4.elem_type = .stone
e4.density = 8000
println("e4: ${e4}")
mut e_water := new_elem()
e_water.name = "water"
e_water.elem_type = .water
e_water.density = 10000
e_water.liquid = true
mut e_concrete := new_elem()
e_concrete.name = "concrete"
e_concrete.elem_type = .concrete
e_concrete.density = 20000
//
// Effects
//
@ -56,8 +39,8 @@ pub fn bits_main() {
mut ef := new_effect()
ef.name = "melt"
ef.in_elem = e2
ef.out_elem = e3
ef.in_elem = bits_ctx.elem_lib["sand"]
ef.out_elem = bits_ctx.elem_lib["glass"]
ef.cond_temp = 5000
// XXX bug: can't print recursive elems?
@ -82,7 +65,8 @@ pub fn bits_main() {
//ob.elem = e4
//ob.mat_info.add_elem_from_size([2, 2, 2], e4)
//ob.parts_info.add_elem_from_size([f32(2.), 2., 2.], e4)
ob.parts_info.add_elem_from_size(2, 2, 2, e4)
//ob.parts_info.add_elem_from_size(2, 2, 2, e4)
ob.mat_info.add_elem_from_size(2, 2, 2, bits_ctx.elem_lib["stone"])
// Position
//ob.transform.pos_x = 10.0
@ -107,11 +91,11 @@ 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.in_elem = bits_ctx.elem_lib["stone"]
//prc.out_elem = e4
//prc.output_factor = 0.6
//prc.req_electricity = true
//prc.req_power = 1000
// XXX
//println("prc: ${prc}")
@ -167,5 +151,10 @@ pub fn bits_main() {
ob2.name = "pipe" // Reinforced-concrete pipe, a 3d object
//ob2.elem = e_concrete
println("")
test_wall()
println("done")
}

50
isotest/bits/material.v
View File

@ -21,45 +21,53 @@ mut:
// XXX or 10% glass 90% concrete?
// XXX do we really need such materials?
//struct ObjectPart {
struct MaterialPart {
mut:
name string
elem &Elem
bits_size int
}
// MaterialInfo information about materials in object
// PartsInfo
struct PartsInfo {
//struct PartsInfo {
struct MaterialInfo {
mut:
//elems map[string]&Elem
//elems map[string]&MaterialElem
elems map[string]&ObjectPart
elems map[string]&MaterialPart
}
fn new_parts_info() &PartsInfo {
pi := &PartsInfo{}
fn new_material_info() &MaterialInfo {
mi := &MaterialInfo{}
return pi
return mi
}
fn (pi &PartsInfo) has_elem(elem &Elem) bool {
return !isnil(pi.elems[elem.name])
fn (mi &MaterialInfo) has_elem(elem &Elem) bool {
return !isnil(mi.elems[elem.name])
}
fn (pi &PartsInfo) has_elem_name(elem_name string) bool {
return !isnil(pi.elems[elem_name])
fn (mi &MaterialInfo) has_elem_name(elem_name string) bool {
return !isnil(mi.elems[elem_name])
}
// Add elem record
fn (mut pi PartsInfo) add_elem(bits_size int, elem &Elem) {
fn (mut mi MaterialInfo) add_elem(bits_size int, elem &Elem) {
pt := &ObjectPart{
pt := &MaterialPart{
elem: elem,
bits_size: bits_size,
}
pi.elems[elem.name] = pt
mi.elems[elem.name] = pt
}
// Get part by elem name
fn (pi &PartsInfo) get_elem_name(elem_name string) &ObjectPart {
fn (mi &MaterialInfo) get_elem_name(elem_name string) &MaterialPart {
pt := pi.elems[elem_name]
pt := mi.elems[elem_name]
//if isnil(me) {
// panic(2)
@ -71,8 +79,8 @@ fn (pi &PartsInfo) get_elem_name(elem_name string) &ObjectPart {
//fn (mut mi MaterialInfo) add_elem_from_size(size [3]f32, elem &Elem) {
//fn (mut pi PartsInfo) add_elem_from_size(size []f32, elem &Elem) {
// println("PartsInfo add_elem_from_size: $size, elem.name: $elem.name")
fn (mut pi PartsInfo) add_elem_from_size(mx, my, mz f32, elem &Elem) {
println("PartsInfo add_elem_from_size: mx: $mx, my: $my, mz: $mz, elem.name: $elem.name")
fn (mut mi MaterialInfo) add_elem_from_size(mx, my, mz f32, elem &Elem) {
println("MaterialInfo add_elem_from_size: mx: $mx, my: $my, mz: $mz, elem.name: $elem.name")
/*
mx := size[0]
@ -85,14 +93,14 @@ fn (mut pi PartsInfo) add_elem_from_size(mx, my, mz f32, elem &Elem) {
println("vol: $vol, vol_bits: $vol_bits")
pi.add_elem(vol_bits, elem)
mi.add_elem(vol_bits, elem)
}
fn (pi &PartsInfo) elems_list() []&ObjectPart {
mut ret := []&ObjectPart{}
for k in pi.elems.keys() {
v := pi.elems[k]
fn (mi &MaterialInfo) elems_list() []&MaterialPart {
mut ret := []&MaterialPart{}
for k in mi.elems.keys() {
v := mi.elems[k]
ret << v
}

18
isotest/bits/object.v
View File

@ -8,13 +8,6 @@ struct ObjectBit {
elem_type ElemType
}
struct ObjectPart {
mut:
name string
elem &Elem
bits_size int
}
struct Object {
mut:
name string
@ -28,8 +21,8 @@ mut:
// Material/Elem
//elem &Elem // XXX use id/enum
//mat_info &MaterialInfo
parts_info &PartsInfo
mat_info &MaterialInfo
//parts_info &PartsInfo
// Position in the world
// XXX in map cells/coords?
@ -56,7 +49,8 @@ fn new_object() &Object {
//elem: &Elem(0),
//mat_info: &MaterialInfo(0),
//parts_info: &PartsInfo(0),
parts_info: new_parts_info(),
//parts_info: new_parts_info(),
mat_info: new_material_info(),
//transform: new_transform(),
}
@ -69,7 +63,7 @@ fn (o &Object) bits_volume() int {
//return o.bits_size
mut ret := 0
for me in o.parts_info.elems_list() {
for me in o.mat_info.elems_list() {
ret += me.bits_size
}
@ -86,7 +80,7 @@ fn (o &Object) mass() f32 {
mut total_mass := 0
for _, me in o.parts_info.elems {
for _, me in o.mat_info.elems {
mat_density := me.elem.density
mat_volume := me.bits_size

93
isotest/bits/processor.v
View File

@ -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,47 +48,69 @@ mut:
fn new_processor() &Processor {
p := &Processor{
in_elem: &Elem(0),
out_elem: &Elem(0),
//out_elem: &Elem(0),
}
return p
}
fn (p &Processor) process(mut o Object) {
fn (p &Processor) process(mut o Object) []&MaterialPart {
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 ret := []&MaterialPart{}
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.mat_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)
// Save initial size
orig_pt_bits_size := pt.bits_size
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
for out_elem_rec in p.out_elems {
processed = true
println("in elem: $p.in_elem.name")
println("out elem: $out_elem_rec.out_elem.name")
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)
new_bits_size := int(orig_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 {
println("replace elem...")
pt.elem = new_elem
pt.bits_size = new_bits_size // XXX fixme?
} else {
println("create new elem...")
// Create new elems
mat_pt := &MaterialPart{
elem: new_elem,
bits_size: new_bits_size,
}
ret << mat_pt
}
processed = true
}
}
}
@ -86,4 +119,6 @@ fn (p &Processor) process(mut o Object) {
}
println("done processing")
return ret
}