The OFFICIAL programming thread

Kilemall

@wingmann said in The OFFICIAL programming thread:

Québec is Canada.

Mwahahaha.

Just like Catalan is Spain?

Wingmann

@kilemall said in The OFFICIAL programming thread:

@wingmann said in The OFFICIAL programming thread:

Québec is Canada.

Mwahahaha.

Just like Catalan is Spain?

Catalan is a language, but yes, Catalunya is Spain.

Gators1

@wingmann said in The OFFICIAL programming thread:

@kilemall said in The OFFICIAL programming thread:

@wingmann said in The OFFICIAL programming thread:

Québec is Canada.

Mwahahaha.

Just like Catalan is Spain?

Catalan is a language, but yes, Catalunya is Spain.

And even they want out. Nobody likes you guys. Maybe they become little Puerto Rico?

Jam

@lob12 said in The OFFICIAL programming thread:

The Code civil du Québec :

http://www.studenthousingguide.co.uk/wp-content/uploads/2017/08/Room.jpg

Now, the Criminal Code of Canada :

http://www.personal.psu.edu/afr3/blogs/siowfa13/RCAT-100MessyRoom.jpg

So English Common Law is a bit messy like a college kids room, but Code Civil du Quebec is like a girl’s bedroom?

Lob12

@jam said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

The Code civil du Québec :

http://www.studenthousingguide.co.uk/wp-content/uploads/2017/08/Room.jpg

Now, the Criminal Code of Canada :

http://www.personal.psu.edu/afr3/blogs/siowfa13/RCAT-100MessyRoom.jpg

So English Common Law is a bit messy like a college kids room, but Code Civil du Quebec is like a girl’s bedroom?

Tidy as fuck.

I googled “tidy rooms” and all I got was girlie rooms :/

Kilemall

@lob12 said in The OFFICIAL programming thread:

@jam said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

The Code civil du Québec :

http://www.studenthousingguide.co.uk/wp-content/uploads/2017/08/Room.jpg

Now, the Criminal Code of Canada :

http://www.personal.psu.edu/afr3/blogs/siowfa13/RCAT-100MessyRoom.jpg

So English Common Law is a bit messy like a college kids room, but Code Civil du Quebec is like a girl’s bedroom?

Tidy as fuck.

I googled “tidy rooms” and all I got was girlie rooms :/

Google understands.

Everything you were up to.

Gustaf

@kilemall said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

@jam said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

The Code civil du Québec :

http://www.studenthousingguide.co.uk/wp-content/uploads/2017/08/Room.jpg

Now, the Criminal Code of Canada :

http://www.personal.psu.edu/afr3/blogs/siowfa13/RCAT-100MessyRoom.jpg

So English Common Law is a bit messy like a college kids room, but Code Civil du Quebec is like a girl’s bedroom?

Tidy as fuck.

I googled “tidy rooms” and all I got was girlie rooms :/

Google understands.

Everything you were up to.

Pedo-Lob

Stu

@lob12 said in The OFFICIAL programming thread:

The modern version has been rewritten 2-3 times in the last 150 +/- years and it was heavily influenced by France’s Code Napoleon.

I understand Napoleonic Code leans towards a “guilty until proven innocent,” view. Does Quebec’s civil code also do that?

Lob12

@stu said in The OFFICIAL programming thread:

@lob12 said in The OFFICIAL programming thread:

The modern version has been rewritten 2-3 times in the last 150 +/- years and it was heavily influenced by France’s Code Napoleon.

I understand Napoleonic Code leans towards a “guilty until proven innocent,” view. Does Quebec’s civil code also do that?

No, but the presumption of innocence is more of a criminal law concept anyway. I don’t know French criminal law at all tbh but I’m quite sure they have something that is very similar. Here is a quote from wiki :

“In France, article 9 of the Declaration of the Rights of Man and of the Citizen of 1789, which has force as constitutional law, begins: “Any man being presumed innocent until he has been declared guilty …” The Code of Criminal Procedure states in its preliminary article that “any person suspected or prosecuted is presumed innocent for as long as their guilt has not been established”[6] and the jurors’ oath repeats this assertion (article 304; note that only the most serious crimes are tried by jury in France). However, there exists a popular misconception that under French law, the accused is presumed guilty until proven innocent.”

In Canada, presumption of innocence in criminal matters is guaranteed by section 11(d) of the Canadian Charter of Rights and Freedoms.

Like I said before, the Code civil applies to non-criminal matters (i.e. tort, contract laws) where the burden of proof basically always falls (unless you were able to demonstrate the existence of a legal presumption) to the party who is making the allegations. Example : Jam pushed me down the staircases and I’m suing him for damages (classic tort case). Well I have to prove that Jam pushed me down the staircase and demonstrate the damages I suffered. The burden of proof I have to satisfy here is not “beyond a reasonable doubt” but more according to a “balance of probabilities”.

What you do find a lot in the civil code is the notion of Good faith vs Bad faith. And one of the first articles of the Book of Evidence states that “Good faith is always presumed, unless the law expressly requires that it be proved.” So if you’re accusing someone of being a lying scumbag in any kind of litigation, or if you pretend that someone’s actions were purposely designed to hurt you in any way, well its up to you to prove it.

Kilemall

I don’t think Canadian OT boards would be fun at all with that kind of proof required!

My Dad tried to get me interested in machine code / assembly programming when I was grade school. He’d bought this thing called the Microprofessor and was happily learning about how setting bits in code translated directly to the hardware.

It wasn’t too long before he was building custom hardware and programming eeproms to control lighting for productions at the theatre where he was the Technical Director.

Anyway, I listened dutifully to every he excitedly tried to teach me on the subject but really had zero interest in it myself. However, just now, 4 decades later, I had a requirement to store cartesian coordinates as a single unsigned integer and boy I’m glad I understood enough of what he taught me to not be put off by things like two’s-complement and bit shifting/masking.

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
        var mask_high = (1 << BITS_PER_DIMENSION) - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

Gators1

@hog said in The OFFICIAL programming thread:

My Dad tried to get me interested in machine code / assembly programming when I was grade school. He’d bought this thing called the Microprofessor and was happily learning about how setting bits in code translated directly to the hardware.

It wasn’t too long before he was building custom hardware and programming eeproms to control lighting for productions at the theatre where he was the Technical Director.

Anyway, I listened dutifully to every he excitedly tried to teach me on the subject but really had zero interest in it myself. However, just now, 4 decades later, I had a requirement to store cartesian coordinates as a single unsigned integer and boy I’m glad I understood enough of what he taught me to not be put off by things like two’s-complement and bit shifting.

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
	var mask_high = 2 ^ BITS_PER_DIMENSION - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

???

Next time please post tits.

@gators1 said in The OFFICIAL programming thread:

???

I’m making a game with a map where everything is a at a position that is a grid reference away from the center. So player X might be at grid reference (-2, 1), and there might be a big impassable rock at (1, 0).

However, the pathfinding API (the library that tells me how the player moves from one location to another,) requires that each point on the map be expressed/id’d as a single number greater than zero.

So, how do you take something like (-2,1) or (1,0) and create a single, unsigned, numbers from them like 3 or 14 and then later take 3 or 14 and turn it back into (-2,1) and (1,0)? That’s what my code does.

Oh, and:

Gators1

@hog said in The OFFICIAL programming thread:

@gators1 said in The OFFICIAL programming thread:

???

I’m making a game with a map where everything is a at a position that is a grid reference away from the center. So player X might be at grid reference (-2, 1), and there might be a big impassable rock at (1, 0).

However, the pathfinding API (the library that tells me how the player moves from one location to another,) requires that each point on the map be expressed as a single number greater than zero.

So, how do you take something like (-2,1) or (1,0) and create a single, unsigned, numbers from them like 3 or 14 and then later take 3 or 14 and turn it back into (-2,1) and (1,0)? That’s what my code does.

Wait, did Jerry hire you to work on his game? You know it’s a scam, right?

rote7

@hog said in The OFFICIAL programming thread:

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
        var mask_high = (1 << BITS_PER_DIMENSION) - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

My bit shifting days are but a remote memory so you may have to help me understand how

var id = col_shifted + row_normalized

does not overwrite the previously stored pattern in col_shifted.

Blanks

@hog said in The OFFICIAL programming thread:

Oh, and:

Maybe you should program this forum. That’s award winning content right there.

@rote7 said in The OFFICIAL programming thread:

@hog said in The OFFICIAL programming thread:

const BITS_PER_DIMENSION = 2
const MAX_EXTENT = 1 << (BITS_PER_DIMENSION - 1)

func _ready():
	print("Bits per dimension: %d, Max extent: %d" % [BITS_PER_DIMENSION, MAX_EXTENT])
	var ids = []
	for col in range(-MAX_EXTENT, MAX_EXTENT):
		var col_normalized = col + MAX_EXTENT
		var col_shifted = col_normalized << BITS_PER_DIMENSION
		for row in range(-MAX_EXTENT, MAX_EXTENT):
			var row_normalized = row + MAX_EXTENT
			var id = col_shifted + row_normalized
			ids.push_back(id)
			print("col: %4d, row: %4d, id: %4d" % [col, row, id])
	
	print("**************** Reversed **************")
        var mask_high = (1 << BITS_PER_DIMENSION) - 1
	print("mask high: %d" % mask_high)
	for id in ids:
		var row_normalized = id & mask_high
		var row = row_normalized - MAX_EXTENT
		var col_normalized = id >> BITS_PER_DIMENSION
		var col = col_normalized - MAX_EXTENT
		print("col: %4d, row: %4d, id: %4d" % [col, row, id])

Result:

--- Debugging process started ---
Godot Engine v3.3.2.stable.official - https://godotengine.org
OpenGL ES 2.0 Renderer: GeForce 940MX/PCIe/SSE2
OpenGL ES Batching: ON
 
Bits per dimension: 2, Max extent: 2
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15
**************** Reversed **************
mask high: 3
col:   -2, row:   -2, id:    0
col:   -2, row:   -1, id:    1
col:   -2, row:    0, id:    2
col:   -2, row:    1, id:    3
col:   -1, row:   -2, id:    4
col:   -1, row:   -1, id:    5
col:   -1, row:    0, id:    6
col:   -1, row:    1, id:    7
col:    0, row:   -2, id:    8
col:    0, row:   -1, id:    9
col:    0, row:    0, id:   10
col:    0, row:    1, id:   11
col:    1, row:   -2, id:   12
col:    1, row:   -1, id:   13
col:    1, row:    0, id:   14
col:    1, row:    1, id:   15

My bit shifting days are but a remote memory so you may have to help me understand how

var id = col_shifted + row_normalized

does not overwrite the previously stored pattern in col_shifted.

Sure, it’s a combination of three things:

they’ve both been converted to unsigned ints (normalized) so the highest bit isn’t set in either number
and the lowest bits of col_shifted are 0 because of the shift
row_normalized only has the lowest bits set because the size of the number is constrained to +/- MAX_EXTENTS

So, even with maximum values for row and column, the addition is like:

00001100 col_shifted +
00000011 row_normalized =
--------
00001111

Edit: by the way, the code i posted earlier was just a proof of concept. My actual use case (which I’ve since coded) has three dimensions. It is using 22 bits (9 + 9 + 4) for a map of 512x512x16 possible locations.

This post is deleted!

Pakoon