Also I'm centered on origin

OK, so you'll need to transform to move the origin to the corner, do the above, then apply the reverse of the original transform.

(Also, I assume you don't really mean it "doesn't work", you mean that your specification was wrong. )

@gimymblert - So you by "hash" and "bucket" you just mean you want to take an arbitrary position and quantise it to the closest red dot?

If so, two steps:

1) Work out which cube face you're on (just by checking which axial component is maximum length).

2) If <u,v> is your position, the output you want is <floor(u+w/2),floor(v+h/2)> where w and h are the (probably equal) width and height of the surface cells in the u/v coordinate system.

Have you tried emacs? If the functionality you are looking for isn't there or a addon package you can add it to your config.

Technically this is true, but it's actually quite a tricky task to write colouring systems in emacs unless they're compatible with font-lock or one of the other built-in colouring frameworks. I use a custom colouring system much simpler than what Timmy wants and it took a surprisingly long time to make it work.

I'm not a security expert, so excuse me if this is a bit of a noob question, but why is it OK to assume here that the attacker can't simply change the code to not use XOR (and then replace the image easily)?

I mean, if the attacker really can't read the code then wouldn't it be a much simpler approach to just take a hash of the image and compare with expected values compiled into the code? That would result in much better performance whilst requiring less code, less complexity and potentially even being harder to hack because you can hide the check anywhere.

[Edit]

That's amazing to hear! Thank you! If you have a minute to spare a simple honest review on the Asset Store would be very appreciated, I seem to be stuck in a review rut :/

Will definitely do this at some point, but would like to get a bit further through my test project first.

Edit: Review added!

Have been playing around with this a bit. It's fun, and very easy to use so far.

Spotted another (trivial) error: On the features page in the section "Changing Layer Sprite Sheet" the referenced example appears to be missing.

Having had a quick look at the site, it doesn't seem that you're playing the games you're reviewing?

Since that's literally the only point of a review, you might want to change this policy.

I do personally think that it's both inadvisable and quite impossible to learn anything as complex as Unity (like 3D modelling packages and so on, or even programming itself) by reading up on everything first and then getting into it with the full knowledge: IMO it has to be done by practice to gain experience every step of the way.

Very much this. If you want to make big things, make small things first.

I switched to Unity as my main development platform about seven years ago and would still consider myself not much beyond a beginner in most respects. It's a very complex system.

Have been reading the API. FontSetup says "If monospaced is true then FES will automatically trim any horizontal empty space on either side of the glyph. If monospaced is false then the empty space is retained." ...isn't that the wrong way around?

Ooh, looks good! Might have to have a play with this... 

How much do you think it would cost?

Impossible to say without a proper spec.

I'd expect to charge around $3000 for a project like this assuming the target platform is PC, but my experience with freelancing in the past has been that clients always miss dozens of important things out of their initial spec. Your project is likely more complex than you've made it sound and so you're probably going to need a higher budget to guarantee completion to your satisfaction.

Also note that it can be cheaper to pay a programmer by the hour. The reason being, if a programmer is asked for a flat fee they have to bill you for the uncertainty, so it typically works out higher.

The trouble with bundles is that you make no money. It's a very bad idea to bundle before regular sales, because then everyone who wants your game picks it up for nearly nothing.

Streamers and YouTubers are a popular free marketing option, but the catch is that the ones with real reach already have more game offers than they can play.

(I haven't got any good tips though, sorry. My own attempts at $0 marketing have not gone well!)

With a $2.99 price tag, I will break even with less than 4000 copies which sounds reasonable.

Bear in mind that 4000 sales is enough that it will be very hard work to achieve without a marketing budget (and may prove impossible).

A very rough guideline is to look at how many people follow your dev work (adding up FaceBook, Twitter and everything else that amounts to some kind of reach) and multiply by the fraction who you think will buy a copy (somewhere around 1%-10% as a rough guess). So to get 4000 sales you'd need a reach of at least 40000.

Of course, you can also get sales from word of mouth recommendations and so on, but for most games that's so close to zero that it makes no difference.

tl;dr - I suspect you'll need some marketing.

The trouble with that kind of approach is that it assumes code formatting adds no information. And, indeed, it doesn't if you do it badly.

People can be very dogmatic about formatting, and a lot of choices either genuinely don't matter or what's best varies with language and task... but good formatting can massively improve productivity. Improved code readability makes bugs easier to spot and if comments are easy to write and look nice then code ends up better commented.

Sure, but the point is that the much simpler mapping I give above still acts as a spatial hash, the question is whether you mind the distortions it creates in which the transformation is not area-preserving.

Trying out your SQRsphereToCube function, it maps sphere <0,0.6,0.8> to "cube" <-1.6,-1.7,1>... so it looks like the face detection part is correct but your on-face maths is wrong.

I don't have time to go through debugging the equations, but I have to ask: do you really need a particular projection for your project? Because I'd just do this:

Code:

private Vector3 cubeToSphere(Vector3 v) {
 return(v.normalized);
}

private Vector3 sphereToCube(Vector3 v) {
 float asx = Mathf.Abs (v.x);
 float asy = Mathf.Abs (v.y);
 float asz = Mathf.Abs (v.z);
 float amax = Mathf.Max(asx,Mathf.Max(asy,asz));
 return(v/amax);
}

...which is far easier to work with!

Ironically, I'd guess the "Rule of Economy" works against several of these rules from time to time.

Which is good, because that reflects the nature of programming as an activity. No style guide can tell you how to resolve tradeoffs in specific cases.

Nice work. I like that the IPoolable interface provides some scope for script support, which most Unity pool managers fail to do.

Still a little awkward when using third party libraries involving scripts, but that's a horrible case to handle, so entirely excusable.

For me, elegant code is defined by the negative space that is ugly code. I don't notice elegant code. I notice when something's hard to read, semantically nasty or inefficient. Some examples:

* Javascript's scoping rules.
* Doing things in loops that could be done outside the loop.
* Functions that take lots of non-optional parameters.
* Code which is full of calls but you can't tell which code is being called.
* Code which uses five classes and ten interfaces for a job one class could do just fine.
* 200+ line functions.
* Almost anything written in C++, especially by me.
* Memory allocation happening avoidably inside the game loop.
* Hardcoded magic numbers.
* Tab characters in source code.
* Any style of parenthesis use which doesn't exactly match my personal preferences.
* Code comments with no capital letters (or all capital letters, but that's mercifully rare).
* Use of inappropriate design patterns because the programmer bought a book on design patterns.
* Using <boolean expression>?<value 1>:<value 2> in code written after 1980.
* Needlessly abbreviated variable names.
* Using horrible hacks where the language/environment has a perfectly good way to do the thing built in.

etc. etc.

Basically I hate most code, so when I find something I don't hate it's an unexpected pleasure!

Unity's physics systems do not guarantee to prevent overlap, since this is very difficult to do in the general case.

One hack which might help is to extend the floor colliders so that they overlap one another by about half the width of the character. This will prevent the corrective forces from collisions with the floor being applied parallel rather than perpendicular to the surface.