ENIGMA Development Environment

Sorry for the late reply but...

I'm writing a Qt project right now, and I assure you that C++ data structures are WAY more difficult to learn and use than the GM's counterpart.

I think there's a chance that these simple structures will be the most used, at least for starters.

What Enigma is trying to do is merging a complex but consistent language (C++) with a simple but inconsistent language (GML), while keeping compatibility.

In the face of the recent news (Python3, C++11, Java7) showing us how difficult and problematic it is to just to keep compatibility between two version of the SAME language, reaching Engima's objective seems to me like a damn development nightmare.

I think it's better to break compatibility between GM8 and Enigma1 now, than breaking it between Enigma1 and Enigma2 later.

I know you guys use Code::Blocks for your projects, and I'm trying to get used to it too.

But there's something I miss a lot from Netbeans, automatic code indentation/formatting.

Is there a plugin which can add this feature into C::B?

In Netbeans you can decide things like spaces, for example, should it be a/b or a / b
and then you can select the code > right click > Format and it applyes the new style.

The problem is that LGM is set up using various design patterns and require a fair amount of abstract thinking. A lot of my desired changes would not be simply "code this", but rather "modularize this so we can use it easier and so it's easier to understand." Something you don't usually get with non-sentient code monkeys in a crate.


Also, I should mention that I did nothing special to implement 'other' yet, so as far as I can tell, 'other' is not populated.

Quote

It'd be cool if it had one where it set values passes as pointers (a _ext version) of the exact collsision coordinates. but im happy for at least 2 weeks.

The rectangle-line collision algorithm does not support this, afaik - it was implemented in an efficient way just for doing a boolean check. There are various line-clipping algorithms which would give you the coordinates where a line meets the boundaries of a rectangle, but they are nowhere near as efficient as the current algorithm. At any rate, anybody is welcome to implement them and stick them in the collision-utilities backend.

I was working on a polygon-line distance/collision function as a part of my C++ dll, and it does return the coords of impact. The coder I hired seem to have stopped working, though

Sooner or later you'll have to document the project, right?

BTW add a link to the wiki on the top of the site when you are finished.

Registered and voted.

If anybody wants to start early testing, I attached the dll C::B C++ code to this post. Licence is GPLv3.
If you'd prefer a more permissive licence, let me know. Any feedback is appreciated, just keep in mind some minor fixes are still needed.

Now the coder I rented plans on debugging it using Visual Studio because he said it's easier to make a debugging project in it.

I was meaning to create another project for testing (inside the same solution), but I couldn't find a way to do it in CodeBlocks.

Here is a brief description of the content. There should be 2 versions of the same function, one for use in C++ code and a dumber one that's GM compatible.

1) A function that, given a 3d segment and 3d planar convex

_cpp version
- if there is an intersection, returns
-- the coordinates of the intersecting points
-- distance=0
- if there isn't, returns
-- the coordinates of the closest points
-- the distance between the closest points

_gm version
- if there is an intersection, returns
-- the distance from the first point of the segment to the intersection point
- if there isn't, returns
-- the distance from the first point of the segment to the point of the segment that is closest to the convex polygon, as a negative value

2) a function that, given 2 segments

_cpp version
- if there is an intersection, returns
-- the coordinates of the intersecting points
-- distance=0

- if there isn't, returns
-- the coordinates of the closest points
-- the distance between the closest points

_gm version
- if there is an intersection, returns
-- the distance from the first point of the segment to the intersection point
- if there isn't, returns
-- the distance from the first point of the first segment to closest point of the second segment, as a negative value

3) a function that, given 2 points returns
- the distance between them

4) a function that, given a 3d point and a 3d planar convex, returns
- if the point is above the convex or part of it, the distance from the convex
- if the point is under the convex or not part of it, the distance from the convex as a negative value

5) a function that, given a 3d point and a 3d planar convex, returns

_gm version
- the x-y direction (360 degrees) to take to get away from the convex as fast as possible if you are on the point

_cpp version
- a vector pointing the direction to get away from the convex as fast as possible if you are on the point

6) a function that, given a 3d triangle and a 3d axis-aligned rectangular prism, returns
- 1, if the triangle is inside the prism or touches it or contains it
- 0, if the triangle is completely outside the prism

7) a function that, given a 3d convex and the x-y coordinates of one of its points, returns
- the the z value of that point

Really? I thought every 3D game used bboxes.