The short answer is you can't do it. Anything that runs client side, especially from source, can be modified to defeat your tactics trivially. If you put in place a client side checker to look for abrupt changes, a user can just disable the checker.
The good news is that, generally, there is very little cheating on single-player games. The only major ...
Just putting all the files into a .zip file isn't a viable solution because most web-applications need a web-server so that they can access resources via HTTP-requests. On some systems you can access files via the file:// URI-scheme, but that's not guaranteed to work everywhere because of security-reasons and will fail for things such as AJAX requests.
You can embed images in the HTML document using the dataurl-syntax which allows to put the base64 representation of the binary image data as the src-attribute of an image. This also works on any other kind of media file.
Don't just send an integer score to the server. Send a collection of game stats that can be used to verify the score was realistic. Or you can implement some pre-shared key for calculating the score. You could send incremental scores and stats throughout the game and ensure that the increase is reasonable.
However, I wouldn't worry too much about it. The ...
I agree with Ef Es, get a couple of people, parents/friends whoever, and watch them play through it. It's the worse to launch a game only to find it really hard because you were use to the game mechanics.
I suggest maybe making a blog of the launch of your game, just go over the details, any updates can be listed there as well.
If money isn't a concern, ...
Let's start with the array. Don't think about it as tridimensional. Indeed, if you want to have stackable units there, it makes sense at first sight:
first dimension is collumns of rows of tiles
second dimension is rows of tiles
third dimensions is tiles, i.e. arrays of units.
But this third dimension won't be consistent, as you will store there not only ...
Phaser has support for two types of sprite sheet: "classic" ones, where every frame is the exact same size, and "texture atlases" which are created with the help of a third party app like Texture Packer, Shoebox or Flash CC and come with an associated json file.
You load the "classic" ones with game.load.spritesheet where you must specify the width and ...
I already answered a question like that here, and I'm sorry to tell but:
I wouldn't bother to make some server side simple checking, but I don't want to go the Diablo 3 path keeping all my game state changes on the server side.
Is the baddest thing you could have say here.
If you wanna do an "anti-cheat" engine, you'll have to do that. You can add ...
Canvas and DOM aren't mutually exclusive, although they are fairly separate. One good approach would be to render the main game area (eg. the falling pieces in Tetris) using Canvas, and do all the UI (eg. score display) with DOM elements that are overlapping the canvas element.
That said, such an approach isn't really necessary for a primitive game like ...
Yes. There are many ways to wrap an HTML5 game for distribution on iOS. Solutions include CocoonJS, Game Closure, PhoneGap, and Ejecta.
Examples of HTML5 games on iOS include Onslaught! on iPad and Biolab Disaster on iPhone.
There were a loooot of options I had to consider, and some others I liked were:
(Incidentally, another option that looks pretty slick initially is http://impactjs.com/ but ...
DOM works pretty well for old-school 2D, that means using no image rotation or scaling. There are actually tools for both of these jobs, but you can't count on them performing well.
For a game you should rely on the browser layout engine as little as possible, that means use position:absolute to place objects. Try as far as possible not to create ...
This means that when the background is drawn, not all of it is redrawn every frame. When something on the map moves, the area it used to occupy gets marked as dirty. Then when drawing, you know you only need to redraw that portion of the background. This is beneficial because then you only need to redraw the areas that weren't shown before.
So this is ...
Just a couple of things to add to @Marco's answer:
.gif is sorely outdated. I would completely avoid using .gif files as much as possible. I think people only use them these days because of in-browser animations, and animated png's aren't well supported at this time.
So all you have is jpg and png.
PNG: Is lossless. The only thing you are considering ...
Add whatever your game needs. Not every engine needs every feature and I strongly recommend you to focus on the ones used by your game, if you ever want to finish working on it.
It's as easy to get lost in collecting engine features as it is to be frustrated later when figuring out that the gain of all this work turned out to be void because those engine ...
For a real-time game, you want to minimize latency. Here's two tips for achieving it, with notes about PHP and Node:
N-grams are popular here. The basic idea is to keep a list of moves the player has made. You can then, given the last N moves of the player, figure out percentage likelihood of what his next move might be.
Your game should have a database of effective counters and blocks to each move.
For offensive modes in the AI, you can still basic player modeling to ...
My bet is that you just hit Google Chrome forbidding XMLHttpRequest on local files by default (see this answer on SO for how to disable that, but beware: this is dangerous). See this page on the Chrome dev site for details.
This is why you have to setup a local HTTP server to workaround ...
Part of the really nice things about the web as it's all human-readable. This makes it an excellent learning resource. If you're telling me that you've never looked at the source of a website to learn how it does something, then feel free to tell me I'm wrong.
I'm all bout sharing the ...
Using transparency (alpha channel) is the way to go, I recommend.
This means that when you want a vertical object on the tile like this:
Then you can do it easily if your renderer draws the tiles back-to-front i.e. painters algorithm.
IMAGE CREDIT: Reiner's tileset.
1) Lack of knowledge. Developing for Canvas might be well beyond some web developers who are very accustomed to manipulating DOM.
2) Lack of a scene graph. The DOM is (in game engine terms) a scene graph, permitting strong querying and manipulation of DOM nodes. Writing a game using Canvas requires the developer to "reinvent" that part of the wheel.
First of all I suggest that you change directions from:
W - up-left
S - down-right
A - down-left
D - top-right
into more intuitive:
W - up
S - down
A - left
D - right
As for your concern, I suggest that you make two functions, one translating isometric tile coordinates into grid coordinates, and second the other way around. That way you could simply ...
As Byte56 said: "never trust the client",
Never trusting the client comes at a price:
Having all games being played on the server will increase your infrastructure cost a lot.
Assuming most of the players won't cheat
and the top highscore will settle after a little time
and stop changing a lot
there is a middle way.
Record the games (on the ...
I think you're making a mistake thinking of a framework as a crutch. Surely when you want to build your own computer, you don't make all your own circuit boards? Mine and smelt the copper yourself?
Frameworks are not crutches. They're tools that make your job much easier. If you truly want to want to get into game development, you'll want to use frameworks....
The image format is only a way to save raw data of pixels, so as long as you use bitmaps, the format usually does not make a difference in execution after the loading step. What matters is the pixel data supplied to the graphics API. There are three formats commonly used in the web:
.gif The (now normally deprecated) GIF format is used for images with 256 ...
People opt for HTML 5 because it's new and flashy. As you mention in your question "...using the new HTML5 technology." It's desirable to be producing something that's using the latest technology, and it's desirable for people to play games that are on the cutting edge. HTML5 fulfills those desires.
I would use HTML5 or simply "web games" "browser games".
It really is debatable on a few things, for the most part browsers now support hardware, so to some degree your hardware will allow more performance, no chance it'll really perform well on devices/phones as a canvas game, they would be better off as an app than something in a webpage.
It is possible to run a good sized canvas game in isometric how ever. But ...
While the method described by sws and MarkR is also what I prefer, I would like to present an alternative approach.
A hackish option for creating an isometric look with minimal effort is to actually use orthogonal tiles, and use context.transform to set a projection matrix which makes the map look isometric (or a combination of context.rotate and context....
Regarding the coordinate system:
In order to address individual tiles, you will need some kind of origin (a 0:0 point). In order to allow the playing field to expand in every direction, you will also need negative values. This will give you a world which stretches from -2.147.483.647 to 2.147.483.647 in both directions, which is "large enough" to seem ...