What am I doing wrong?!?! (global udt variables - weird results)

Author

Message

Neuro Fuzzy

19

Years of Service

User Offline

Joined: 11th Jun 2007

Location:

Posted: 14th Mar 2011 12:32 Edited at: 14th Mar 2011 12:33

Link

So... I have this program... It's kind of odd, and an approximation of a fractal - from "The Fractal Geometry of Nature". So... It's hard to tell what's going on.

My problem is that I have global, user defined types, being used as vectors. The only thing I do to these vectors is average them, or set them to one of three vectors. However, I get points OUTSIDE the triangle defined by these three vectors - points that are impossible to get by just averaging three points! HOW?! I'm pretty sure I'm somehow mistreating global user defined type variables... but... I don't see how. Are user defined types passed by reference?
Here's the code:

type vector2
	x as float
	y as float
endtype
global retvec as vector2
global linevec as vector2
global retvec1 as vector2
global retvec2 as vector2
global retvec3 as vector2
global masterNode as dword
masterNode=alloc zeroed(32)
poke dword masterNode,1
poke dword masterNode+4,2

trivert1 as vector2
trivert2 as vector2
trivert3 as vector2
trivert1.x=10
trivert1.y=10
trivert2.x=10
trivert2.y=screen height()-10
trivert3.x=screen height()-100
trivert3.y=screen height()/2
recurse(masterNode,0)
recurse(masterNode,0)
recurse(masterNode,0)
recurse(masterNode,0)
linevec=trivert1
line trivert1.x,trivert1.y,trivert2.x,trivert2.y
line trivert2.x,trivert2.y,trivert3.x,trivert3.y
line trivert3.x,trivert3.y,trivert1.x,trivert1.y
draw_node(masternode,trivert1,trivert2,trivert3)
sync
wait key
cleanup_node(masterNode)
//0: edge start
//4: edge end
//8: triangle 1
//12: triangle 2
//16: triangle 3
//20: triangle 4
//24: starting cell
//28: ending cell
end
function draw_node(mem as dword,p1 as vector2, p2 as vector2, p3 as vector2)
	zerovec as vector2
	zerovec.x=0
	zerovec.y=0
	if mem=0 
		retvec=zerovec
		exitfunction 0
	endif

if peek dword(mem+8)=0 and peek dword(mem+12)=0 and peek dword(mem+20)=0
		retvec.x=(p1.x+p2.x+p3.x)/3
		retvec.y=(p1.y+p2.y+p3.y)/3
		exitfunction 1
	else
		if peek dword(mem+16)=0
			getSubNodePos(peek dword(mem+24),p1,p2,p3)
			if draw_node(peek dword(mem+4+4*peek dword(mem+24)),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
				exitfunction 0
			endif
		else
		
			getSubNodePos(peek dword(mem+24),p1,p2,p3)
			if draw_node(peek dword(mem+4+4*peek dword(mem+24)),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
			endif			
			getSubNodePos(3,p1,p2,p3)
			if draw_node(peek dword(mem+16),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
			endif			
			getSubNodePos(peek dword(mem+28),p1,p2,p3)
			if draw_node(peek dword(mem+4+4*peek dword(mem+28)),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
			endif
		endif
	endif
endfunction 0
function getSubNodePos(cell as integer, p1 as vector2, p2 as vector2, p3 as vector2)
	if cell=1
		retvec1=p1
		retvec2.x=(retvec2.x+retvec1.x)/2
		retvec2.y=(retvec2.y+retvec1.y)/2
		retvec3.x=(retvec3.x+retvec1.x)/2
		retvec3.y=(retvec3.y+retvec1.y)/2
		exitfunction
	endif
	if cell=2
		retvec2=p2
		retvec1.x=(retvec1.x+retvec2.x)/2
		retvec1.y=(retvec1.y+retvec2.y)/2
		retvec3.x=(retvec3.x+retvec2.x)/2
		retvec3.y=(retvec3.y+retvec2.y)/2
		exitfunction
	endif
	if cell=4
		retvec3=p3
		retvec1.x=(retvec1.x+retvec3.x)/2
		retvec1.y=(retvec1.y+retvec3.y)/2
		retvec2.x=(retvec2.x+retvec3.x)/2
		retvec2.y=(retvec2.y+retvec3.y)/2
		exitfunction
	endif
	if cell=3
		retvec3.x=(retvec1.x+retvec2.x)/2
		retvec3.y=(retvec1.y+retvec2.y)/2
		
		retvec2.x=(retvec1.x+retvec3.x)/2
		retvec2.y=(retvec1.y+retvec3.y)/2
		
		retvec1.x=(retvec3.x+retvec2.x)/2
		retvec1.y=(retvec3.y+retvec2.y)/2
		exitfunction
	endif
endfunction
function recurse(mem as dword, startcell as integer)
	if mem=0 then exitfunction 0
	
	if peek dword(mem+8)=0 and peek dword(mem+12)=0 and peek dword(mem+20)=0
		ret=div_Node(mem,peek dword(mem),peek dword(mem+4),startcell)
		exitfunction ret
	else
		ret=0
		startside=peek dword(mem)
		endside=peek dword(mem+4)
		if peek dword(mem+16)=0
			ret=recurse(peek dword(mem+4+4*peek dword(mem+24)),startcell)
			exitfunction ret
		else
			ret=recurse(peek dword(mem+4+4*peek dword(mem+24)),startcell)
			ret=recurse(peek dword(mem+16),ret)
			ret=recurse(peek dword(mem+4+4*peek dword(mem+28)),ret)
			exitfunction ret
		endif
	endif
endfunction 0

function cleanup_node(mem as dword)
	if peek dword(mem+ 8)>0 then cleanup_node(peek dword(mem+ 8))
	if peek dword(mem+12)>0 then cleanup_node(peek dword(mem+12))
	if peek dword(mem+16)>0 then cleanup_node(peek dword(mem+16))
	if peek dword(mem+20)>0 then cleanup_node(peek dword(mem+20))
	free mem
endfunction

function div_Node(mem as dword,startside as integer,endside as integer,startcell as integer)
	endcell as integer
	endcell=getRandCellTouchingSide(endside)
	if startcell=0
		startcell=getRandCellTouchingSide(startside)
	endif
	poke dword mem+24,startcell
	poke dword mem+28,endcell
	if startcell=endcell
		newmem as dword
		newmem=alloc zeroed(32)
		poke dword mem+4+startcell*4,newmem
		poke dword newmem,startside
		poke dword newmem+4,endside
	else
		newmem as dword
		newmem=alloc zeroed(32)
		poke dword mem+4+startcell*4,newmem
		poke dword newmem,getStartSideStartCell(startcell,endcell,startside,endside)
		poke dword newmem+4,getEndSideStartCell(startcell,endcell,startside,endside)
		
		newmem=alloc zeroed(32)
		poke dword mem+4+endcell*4,newmem
		poke dword newmem,getStartSideEndCell(startcell,endcell,startside,endside)
		poke dword newmem+4,getEndSideEndCell(startcell,endcell,startside,endside)
		
		newmem=alloc zeroed(32)
		poke dword mem+16,newmem
		poke dword newmem,getStartSideMidCell(startcell,endcell,startside,endside)
		poke dword newmem+4,getEndSideMidCell(startcell,endcell,startside,endside)
		
	endif
	ret=0
	select endside
		case 1
			if endcell=1
				ret=2
			endif
			if endcell=2
				ret=1
			endif
		endcase
		case 2
			if endcell=1
				ret=4
			endif
			if endcell=4
				ret=1
			endif
		endcase
		case 3
			if endcell=2
				ret=4
			endif
			if endcell=4
				ret=2
			endif
		endcase
	endselect
endfunction ret

function getEndSideMidCell(startcell as integer, endcell as integer, startside as integer, endside as integer)
	ret=0
	select endcell
		case 1
			ret=3
		endcase
		case 2
			ret=1
		endcase
		case 4
			ret=2
		endcase
	endselect
endfunction ret
function getStartSideMidCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=0
	select startcell
		case 1
			ret=3
		endcase
		case 2
			ret=1
		endcase
		case 4
			ret=2
		endcase
	endselect
endfunction ret
function getEndSideEndCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=endside
endfunction ret
function getStartSideEndCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=0
	select endcell
		case 1
			ret=3
		endcase
		case 2
			ret=2
		endcase
		case 4
			ret=1
		endcase
	endselect
endfunction ret
function getStartSideStartCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=startside
endfunction ret
function getEndSideStartCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=0
	select startcell
		case 1
			ret=3
		endcase
		case 2
			ret=2
		endcase
		case 4
			ret=1
		endcase
	endselect
endfunction ret
function getRandCellTouchingSide(side as integer)
	switchval=rnd(1)
	startcell as integer
	select side
		case 1
		if switchval=1
				startcell=1
			else
				startcell=2
			endif
		endcase
		case 2
			if switchval=1
				startcell=1
			else
				startcell=4
			endif
		endcase
		case 3
			if switchval=1
				startcell=2
			else
				startcell=4
			endif
		endcase
	endselect
endfunction startcell

+ Code Snippet


type vector2
	x as float
	y as float
endtype
global retvec as vector2
global linevec as vector2
global retvec1 as vector2
global retvec2 as vector2
global retvec3 as vector2
global masterNode as dword
masterNode=alloc zeroed(32)
poke dword masterNode,1
poke dword masterNode+4,2


trivert1 as vector2
trivert2 as vector2
trivert3 as vector2
trivert1.x=10
trivert1.y=10
trivert2.x=10
trivert2.y=screen height()-10
trivert3.x=screen height()-100
trivert3.y=screen height()/2
recurse(masterNode,0)
recurse(masterNode,0)
recurse(masterNode,0)
recurse(masterNode,0)
linevec=trivert1
line trivert1.x,trivert1.y,trivert2.x,trivert2.y
line trivert2.x,trivert2.y,trivert3.x,trivert3.y
line trivert3.x,trivert3.y,trivert1.x,trivert1.y
draw_node(masternode,trivert1,trivert2,trivert3)
sync
wait key
cleanup_node(masterNode)
//0: edge start
//4: edge end
//8: triangle 1
//12: triangle 2
//16: triangle 3
//20: triangle 4
//24: starting cell
//28: ending cell
end
function draw_node(mem as dword,p1 as vector2, p2 as vector2, p3 as vector2)
	zerovec as vector2
	zerovec.x=0
	zerovec.y=0
	if mem=0 
		retvec=zerovec
		exitfunction 0
	endif

	if peek dword(mem+8)=0 and peek dword(mem+12)=0 and peek dword(mem+20)=0
		retvec.x=(p1.x+p2.x+p3.x)/3
		retvec.y=(p1.y+p2.y+p3.y)/3
		exitfunction 1
	else
		if peek dword(mem+16)=0
			getSubNodePos(peek dword(mem+24),p1,p2,p3)
			if draw_node(peek dword(mem+4+4*peek dword(mem+24)),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
				exitfunction 0
			endif
		else
		
			getSubNodePos(peek dword(mem+24),p1,p2,p3)
			if draw_node(peek dword(mem+4+4*peek dword(mem+24)),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
			endif			
			getSubNodePos(3,p1,p2,p3)
			if draw_node(peek dword(mem+16),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
			endif			
			getSubNodePos(peek dword(mem+28),p1,p2,p3)
			if draw_node(peek dword(mem+4+4*peek dword(mem+28)),retvec1,retvec2,retvec3)=1
				line linevec.x,linevec.y,retvec.x,retvec.y
				linevec=retvec
			endif
		endif
	endif
endfunction 0
function getSubNodePos(cell as integer, p1 as vector2, p2 as vector2, p3 as vector2)
	if cell=1
		retvec1=p1
		retvec2.x=(retvec2.x+retvec1.x)/2
		retvec2.y=(retvec2.y+retvec1.y)/2
		retvec3.x=(retvec3.x+retvec1.x)/2
		retvec3.y=(retvec3.y+retvec1.y)/2
		exitfunction
	endif
	if cell=2
		retvec2=p2
		retvec1.x=(retvec1.x+retvec2.x)/2
		retvec1.y=(retvec1.y+retvec2.y)/2
		retvec3.x=(retvec3.x+retvec2.x)/2
		retvec3.y=(retvec3.y+retvec2.y)/2
		exitfunction
	endif
	if cell=4
		retvec3=p3
		retvec1.x=(retvec1.x+retvec3.x)/2
		retvec1.y=(retvec1.y+retvec3.y)/2
		retvec2.x=(retvec2.x+retvec3.x)/2
		retvec2.y=(retvec2.y+retvec3.y)/2
		exitfunction
	endif
	if cell=3
		retvec3.x=(retvec1.x+retvec2.x)/2
		retvec3.y=(retvec1.y+retvec2.y)/2
		
		retvec2.x=(retvec1.x+retvec3.x)/2
		retvec2.y=(retvec1.y+retvec3.y)/2
		
		retvec1.x=(retvec3.x+retvec2.x)/2
		retvec1.y=(retvec3.y+retvec2.y)/2
		exitfunction
	endif
endfunction
function recurse(mem as dword, startcell as integer)
	if mem=0 then exitfunction 0
	
	if peek dword(mem+8)=0 and peek dword(mem+12)=0 and peek dword(mem+20)=0
		ret=div_Node(mem,peek dword(mem),peek dword(mem+4),startcell)
		exitfunction ret
	else
		ret=0
		startside=peek dword(mem)
		endside=peek dword(mem+4)
		if peek dword(mem+16)=0
			ret=recurse(peek dword(mem+4+4*peek dword(mem+24)),startcell)
			exitfunction ret
		else
			ret=recurse(peek dword(mem+4+4*peek dword(mem+24)),startcell)
			ret=recurse(peek dword(mem+16),ret)
			ret=recurse(peek dword(mem+4+4*peek dword(mem+28)),ret)
			exitfunction ret
		endif
	endif
endfunction 0

function cleanup_node(mem as dword)
	if peek dword(mem+ 8)>0 then cleanup_node(peek dword(mem+ 8))
	if peek dword(mem+12)>0 then cleanup_node(peek dword(mem+12))
	if peek dword(mem+16)>0 then cleanup_node(peek dword(mem+16))
	if peek dword(mem+20)>0 then cleanup_node(peek dword(mem+20))
	free mem
endfunction

function div_Node(mem as dword,startside as integer,endside as integer,startcell as integer)
	endcell as integer
	endcell=getRandCellTouchingSide(endside)
	if startcell=0
		startcell=getRandCellTouchingSide(startside)
	endif
	poke dword mem+24,startcell
	poke dword mem+28,endcell
	if startcell=endcell
		newmem as dword
		newmem=alloc zeroed(32)
		poke dword mem+4+startcell*4,newmem
		poke dword newmem,startside
		poke dword newmem+4,endside
	else
		newmem as dword
		newmem=alloc zeroed(32)
		poke dword mem+4+startcell*4,newmem
		poke dword newmem,getStartSideStartCell(startcell,endcell,startside,endside)
		poke dword newmem+4,getEndSideStartCell(startcell,endcell,startside,endside)
		
		newmem=alloc zeroed(32)
		poke dword mem+4+endcell*4,newmem
		poke dword newmem,getStartSideEndCell(startcell,endcell,startside,endside)
		poke dword newmem+4,getEndSideEndCell(startcell,endcell,startside,endside)
		
		newmem=alloc zeroed(32)
		poke dword mem+16,newmem
		poke dword newmem,getStartSideMidCell(startcell,endcell,startside,endside)
		poke dword newmem+4,getEndSideMidCell(startcell,endcell,startside,endside)
		
	endif
	ret=0
	select endside
		case 1
			if endcell=1
				ret=2
			endif
			if endcell=2
				ret=1
			endif
		endcase
		case 2
			if endcell=1
				ret=4
			endif
			if endcell=4
				ret=1
			endif
		endcase
		case 3
			if endcell=2
				ret=4
			endif
			if endcell=4
				ret=2
			endif
		endcase
	endselect
endfunction ret

function getEndSideMidCell(startcell as integer, endcell as integer, startside as integer, endside as integer)
	ret=0
	select endcell
		case 1
			ret=3
		endcase
		case 2
			ret=1
		endcase
		case 4
			ret=2
		endcase
	endselect
endfunction ret
function getStartSideMidCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=0
	select startcell
		case 1
			ret=3
		endcase
		case 2
			ret=1
		endcase
		case 4
			ret=2
		endcase
	endselect
endfunction ret
function getEndSideEndCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=endside
endfunction ret
function getStartSideEndCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=0
	select endcell
		case 1
			ret=3
		endcase
		case 2
			ret=2
		endcase
		case 4
			ret=1
		endcase
	endselect
endfunction ret
function getStartSideStartCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=startside
endfunction ret
function getEndSideStartCell(startcell as integer, endcell as integer,startside as integer, endside as integer)
	ret=0
	select startcell
		case 1
			ret=3
		endcase
		case 2
			ret=2
		endcase
		case 4
			ret=1
		endcase
	endselect
endfunction ret
function getRandCellTouchingSide(side as integer)
	switchval=rnd(1)
	startcell as integer
	select side
		case 1
		if switchval=1
				startcell=1
			else
				startcell=2
			endif
		endcase
		case 2
			if switchval=1
				startcell=1
			else
				startcell=4
			endif
		endcase
		case 3
			if switchval=1
				startcell=2
			else
				startcell=4
			endif
		endcase
	endselect
endfunction startcell

Also, there is one line setting a global vector to zero, however, it shouldn't ever be called (It's in case I pass a 0 address into the function on accident), and removing it doesn't change the program at all.

[edit]
also, I think this is similar to the cause of many problems I've had with dbp... ones that I finish (or so I think), can't get to run, port to C++ or something, and have it run perfectly :\

Back to top

Profile PM Email

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 14th Mar 2011 14:03

Link

Can you reproduce the problem with a shorter piece of code?

Back to top

Profile PM Email

Van B

Moderator

23

Years of Service

User Offline

Joined: 8th Oct 2002

Location: Sunnyvale

Posted: 14th Mar 2011 18:13

Link

Perhaps it's an issue with your Vector2 type - that could be conflicting with the vector commands. Maybe change that to t_vector2 or something just to eliminate that.

Also, this command:

retvec1=p1

It looks like your trying to set a typed variable directly, but I don't think that actually works - really you might well be setting one null variable to another in this case. I am sure you would have to do something like this:

retvec1.x = p1.x
retvec1.y = p1.y

Wheras in C++ it can pobably work how you have it, setting a pointer rather than data for example.

Health, Ammo, and bacon and eggs!

Back to top

Profile PM Email

Green Gandalf

VIP Member

21

Years of Service

User Offline

Joined: 3rd Jan 2005

Playing: Malevolence:Sword of Ahkranox, Skyrim, Civ6.

Posted: 14th Mar 2011 21:16 Edited at: 14th Mar 2011 21:31

Link

Quote: "but I don't think that actually works "

Yes it does.

Quote: "Perhaps it's an issue with your Vector2 type "

I wondered about that - but the compiler accepts it and works in simple cases. I think the problem lies elsewhere so it would definitely help to have short simple code showing the same problem.

Edit The following very simplified version of your code computes the averages correctly.

+ Code Snippet

p2 as vector2
p3 as vector2

p1.x = 1
p1.y = 1
p2.x = 1
p2.y = 3
p3.x = 3
p3.y = 1

average(p1, p2, p3)

print p.x, " ", p.y
wait key

end

function average(v1 as vector2, v2 as vector2, v3 as vector2)
  p.x = (v1.x+v2.x+v3.x)/3
  p.y = (v1.y+v2.y+v3.y)/3
endfunction

Back to top

Profile PM Email

Neuro Fuzzy

19

Years of Service

User Offline

Joined: 11th Jun 2007

Location:

Posted: 14th Mar 2011 22:15

Link

I think it might have something to do with the code being a recursive mess... but I'm still not totally sure what I could do to isolate the problem :\

Back to top

Profile PM Email

IanM

Retired Moderator

23

Years of Service

User Offline

Joined: 11th Sep 2002

Location: In my moon base

Posted: 14th Mar 2011 23:24

Link

How about rewriting all of those allocs, peeks and pokes in a pseudo-OO way. Frankly all of that pointer arithmetic is confusing and hides what you are trying to do - I certainly find it confusing.

Try using something like this for a start (untested):

//0: edge start
//4: edge end
//8: triangle 1
//12: triangle 2
//16: triangle 3
//20: triangle 4
//24: starting cell
//28: ending cell

function Node_Construct()
    exitfunction alloc zeroed(32)
endfunction 0

function Node_Destroy(mem as dword)
    if mem
        Node_Destroy( Node_Get_Triangle(mem, 0) )
        Node_Destroy( Node_Get_Triangle(mem, 1) )
        Node_Destroy( Node_Get_Triangle(mem, 2) )
        Node_Destroy( Node_Get_Triangle(mem, 3) )
        free mem
    endif
endfunction

function Node_Get_Edge_Start(mem as dword)
    exitfunction peek dword(mem)
endfunction 0

function Node_Set_Edge_Start(mem as dword, value as dword)
    poke dword mem, value
endfunction

function Node_Get_End_End(mem as dword)
    exitfunction peek dword(mem + 4)
endfunction 0

function Node_Set_Edge_End(mem as dword, value as dword)
    poke dword mem + 4, value
endfunction

` Triangle node array numbered from 0
function Node_Get_Triangle(mem as dword, item as dword)
    inc mem, (item * 4) + 8
    exitfunction peek dword(mem)
endfunction 0

function Node_Set_Triangle(mem as dword, item as dword, value as dword)
    inc mem, (item * 4) + 8
    poke dword mem, value
endfunction

function Node_Get_Start_Cell(mem as dword)
    exitfunction peek dword(mem + 24)
endfunction 0

function Node_Set_Start_Cell(mem as dword, value as dword)
    poke dword mem + 24, value
endfunction

function Node_Get_End_Cell(mem as dword)
    exitfunction peek dword(mem + 28)
endfunction 0

function Node_Set_End_Cell(mem as dword, value as dword)
    poke dword mem + 28, value
endfunction

+ Code Snippet

//0: edge start
//4: edge end
//8: triangle 1
//12: triangle 2
//16: triangle 3
//20: triangle 4
//24: starting cell
//28: ending cell

function Node_Construct()
    exitfunction alloc zeroed(32)
endfunction 0

function Node_Destroy(mem as dword)
    if mem
        Node_Destroy( Node_Get_Triangle(mem, 0) )
        Node_Destroy( Node_Get_Triangle(mem, 1) )
        Node_Destroy( Node_Get_Triangle(mem, 2) )
        Node_Destroy( Node_Get_Triangle(mem, 3) )
        free mem
    endif
endfunction


function Node_Get_Edge_Start(mem as dword)
    exitfunction peek dword(mem)
endfunction 0

function Node_Set_Edge_Start(mem as dword, value as dword)
    poke dword mem, value
endfunction

function Node_Get_End_End(mem as dword)
    exitfunction peek dword(mem + 4)
endfunction 0

function Node_Set_Edge_End(mem as dword, value as dword)
    poke dword mem + 4, value
endfunction

` Triangle node array numbered from 0
function Node_Get_Triangle(mem as dword, item as dword)
    inc mem, (item * 4) + 8
    exitfunction peek dword(mem)
endfunction 0

function Node_Set_Triangle(mem as dword, item as dword, value as dword)
    inc mem, (item * 4) + 8
    poke dword mem, value
endfunction

function Node_Get_Start_Cell(mem as dword)
    exitfunction peek dword(mem + 24)
endfunction 0

function Node_Set_Start_Cell(mem as dword, value as dword)
    poke dword mem + 24, value
endfunction

function Node_Get_End_Cell(mem as dword)
    exitfunction peek dword(mem + 28)
endfunction 0

function Node_Set_End_Cell(mem as dword, value as dword)
    poke dword mem + 28, value
endfunction

Get the latest Matrix1Utility plug-ins (23-DEC-2010)

Back to top

Profile PM Email Website

Diggsey

20

Years of Service

User Offline

Joined: 24th Apr 2006

Location: On this web page.

Posted: 15th Mar 2011 03:07

Link

You can save on the number of functions you need by having generic read and write functions for each type and specify the offset using a constant, ie:

+ Code Snippet

#constant EDGE_START 0

edgeStart = GetInteger(ptr, EDGE_START)

function GetInteger(ptr, offset)
    result = peek integer(ptr + offset)
endfunction result

[b]

Back to top

Profile PM Email Website

Neuro Fuzzy

19

Years of Service

User Offline

Joined: 11th Jun 2007

Location:

Posted: 21st Mar 2011 13:50 Edited at: 21st Mar 2011 13:50

Link

Hmm... I'll definitely do that in the future.

Anyways, I applied the same concept, and wrote some C++ code, and got it working first compile, so now I'm certain the problem is either
(A) Some misconception I have about DBPro or
(B) A bug in DBPro

I still have no clue though...

If you're wondering WHAT I'm doing, I wrote up some stuff about it on my website (pictures I've made are at the bottom of that page) aaand on the forums (2nd to last post)

Back to top

Profile PM Email

IanM

Retired Moderator

23

Years of Service

User Offline

Joined: 11th Sep 2002

Location: In my moon base

Posted: 21st Mar 2011 15:07

Link

or (C) some bug in your code.

There are so many address calculations in there that I have no idea what's going on for a large portion of the time - that's why you should try to encapsulate your memory accesses.

Get the latest Matrix1Utility plug-ins (23-DEC-2010)

Back to top

Profile PM Email Website

Neuro Fuzzy

19

Years of Service

User Offline

Joined: 11th Jun 2007

Location:

Posted: 21st Mar 2011 16:11

Link

I get that it's unclear, but the problem is: vectors being averaged and coming out with impossible results. Since I never set any value of any vector to something read from memory, I think that's a separate thing from the bug. In other words, "I know I'm probably overlooking something, but I don't think memory access is the issue" (A programmer's famous last words

)

Back to top

Profile PM Email

IanM

Retired Moderator

23

Years of Service

User Offline

Joined: 11th Sep 2002

Location: In my moon base

Posted: 21st Mar 2011 22:21

Link

But you are writing to memory - could be that you are overwriting the odd vector here and there.

Now I'm not saying that's what the problem is, but as that's the most unclear part of the code, that's what I'd target first. Wrapping it up in functions would allow you to at least put in a standard check that you aren't writing memory out of bounds of the allocated memory.

Get the latest Matrix1Utility plug-ins (23-DEC-2010)

Back to top

Profile PM Email Website

Neuro Fuzzy

19

Years of Service

User Offline

Joined: 11th Jun 2007

Location:

Posted: 30th Mar 2011 02:55 Edited at: 30th Mar 2011 10:03

Link

[edit]
:\
nevermind...

Back to top

Profile PM Email

Sorry your browser is not supported!

DarkBASIC Professional Discussion / What am I doing wrong?!?! (global udt variables - weird results)