So in physics we were supposed to be doing a predict-the-electric-field activity, but instead I decided to spend the time writing a program that could do it for me (Axe). I think it's not too shabby, but if someone could help me fine-tune the accuracy of it a bit? In some situations it behaves oddly. Source (Axe) is in prgmA0E.

Controls:
2nd: place positive charge
Alpha: place neg. charge
Enter: advance scenario

Complete Axe Tutorial (in french) by kindermoumoute


General:

Learning Binary by z80man: A quick explanation on this intricate system of numbers. 101010!

Explanation of pointers by Deep Thought: An excellent post detailing the basics of pointers for people new to Axe or otherwise low-level languages.

Launching external ASM programs from an application by squidgetx: credit goes mainly to Runer112 and FinaleTI though.

Program Flow Basics for a Platformer by Eeems: A short guide on how to setup your program so that it is easy to handle and relatively quick.


Specific Functions and Commands:

Table of Frequencies for use with the Freq() command accompanied by an explanation by Floppus Maximus

Bit Manipulation by Hot_Dog, Runer112, and nemo: A somewhat slapdash series of posts detailing how to read and write to bits.

The ** command by nemo: a full tutorial on fixed point multiplication.

Fix command tutorial by Scout: A more indepth explanation of the Fix command than the documentation.

Interrupts Tutorial by Hot_Dog: A detailed PDF showing how to maximize the effectiveness of interrupts in Axe

Using Axe to its full functional form ? by Ashbad: A nicely written tutorial on how to take advantage of many of Axe 1.0.0's new features including lambdas, getting label addresses, etc.

Lazy Evaluation by Ashbad: Another excellent tutorial this time discussing how to implement lazy evaluation in an Axe environment.


Game Mechanics:

Physics Lessons by Builderboy: A great collection of physics lessons explaining gravity, cellular automata, trig, and more! (Sorry Builderboy, I unstickied it for now, you can put it back up if you want)

Slope Physics Tutorial by squidgetx: an indepth-exploration/physics lesson.

Arrays and Bullet Code by Deep Thought: A work-in-progress on manipulating complex data structures, geared specifically towards coding bullet and ememy systems.

SHMUP tutorial by Deep Thought: In-the-works tutorial on making a Shoot-em-up game, building further on many of the concepts from the Array tutorial.

New Tilemapping Tutorial by yunhua98: a look at smoothscrolling tilemapping

Tilemapping Tutorial by SirCmpwn: The first comprehensive tilemapping tutorial including tilemap detection/collision

thydowulays's Complete n00bs guide to Tilemapping in Axe by thydowulay: Well, as the title says, a beginner's guide to tilemapping. Introduces basic concepts and sample code.

Beginner's Physics Tutorial by Scout:  A look at physics from the beginner's point of view.

OS and Data

External Variables Tutorial by FinaleTI: A comprehenisve tutorial on using the OS external variables such as appvars, real variables, lists, and more.

VAT tutorial by squidgetx: A tutorial showing how to go through the program table on the calc to retrieve programs/appvars

Pseudo-Huffman Compression by shmibs: A not-really-huffman compression technique that nevertheless is valid and useful.

Huffman Compression by Runer112: Runer112's response; focused on how to generate and use a Huffman compression tree.


Graphics:

Flame Graphics by Builderboy: Simple and easy way to create awesome fire effects in games.

Axe Grayscale Tutorials by Scout and squidgetx: Two short and simple tutorials on how to use grayscale in Axe

8 level grayscale by willrandship and kindermoumoute: O.o

Particluar Explosion Tutorial by leafiness0

Quick Grayscale Tutorial

3 level gray:
Three level grayscale is utilized by using the command DispGraph^r in place of the normal DispGraph command. Three level gray uses the backbuffer (L3) and the front buffer (L6). Everything on the back buffer will show as gray while everything on the front buffer will show as black. The front buffer is drawn over the back buffer, so if a pixel is "on" on both the front and back buffers, it will be shown as black.

You can change the common drawing operations Pt-On, Pt-Off, Pt-Change, Pxl-On, ClrDraw, Rect, Line, DrawInv, etc. to operate on the back buffer by adding the raidan ^r at the end of the command. For example, Pt-On(X,Y,Pic1)^r will draw Pic1 to the backbuffer. If you then look at it with DispGraph, you will see it in gray.

Text, by default is drawn directly to the screen and not to the buffer. For this reason, it can appear as grayscale because it is being erased every time you call DispGraph^r, and then redrawn very quickly. To make it so that text is drawn to the buffer, put a Fix 5 at the beginning of the program (and a Fix 4 at the end). To draw text to the back buffer, you will have to Exch the back and front buffers, write to the front buffer, and switch back: Exch(L3,L6,768): Text(X,Y,"Text") : Exch(L3,L6,768)
4 level gray
With four level gray, the front buffer becomes somewhat transparent. Use the following table to figure out the pixel colors:Front:Back:Color
0    :1   :Light Gray
0    :0   :White
1    :0   :Dark Gray
1    :1   :Black
Buffer operations remain the same. To display in four level gray, use DispGraph^rr

Note: In order for the grayscale to show up, you must put the DispGraph^r or DispGraph^rr in a loop. In monochrome, you can get away with this::Pt-On(X,Y,Pic1)
:DispGraph
:Repeat getKey
:EndBut with grayscale, you'll have to write the code like this::Pt-On(X,Y,Pic1)
:Repeat getKey
:DispGraph[sup]r[/sup][sup]r[/sup]
:End
edit: 1000 posts

Quigibo has released version 0.5.0 of the hugely popular Axe Parser, taking the project out of delta and into epsilon! Some notable new features include the now fully functional axiom system as well as EndIf and End!If commands for loops!

The new update can be downloaded here

From the original topic:

Axe Parser
Epsilon 0.5.0

---

New Features:

• Axioms finally fully functional!
• Example axiom included.
• "While 1" and "Repeat 0" automatically optimize to "Do" loops.
• New "EndIf" and "End!If" statements for post-testing in loops.
• Help menu actually shows something now!

Changed:

• Fixed sprite rotation commands.
• Fixed nibble reading commands.

We applaud Quigibo for this update and wish him good luck with version 1.0.0

The Axe Parser subforum has been split into two parts: the Axe Project forum and the Axe Language forum. This is to help separate the Axe project discussion from tutorials and other language help/support as the original forum was becoming rather crowded. Now, language help and tutorials can go in the newly created Axe Language board, while project disucssion will continue in the original Axe parser subforum. Hopefully this will help to organize things a bit better, and apologies for any inconvenience.

Why would you need this??? We have calculators!

Anyway, thought some of you guys would appreciate this

edit: holy, massive picture

This is a project that was inspired by Builderboy's Cellular Automata physics tutorial (hence the name). Ironically it currently does not have any kind of particle physics or cellular automata in it at all. For now I'm just working on the main character physics, and I've managed to produce something I thought was worthy enough to post and officially unveil this previously secret project

More details on gameplay will be unveiled later, as I think that if I succeed, I want it to be a surprise (because it will look really, really cool). For now you can just know that it will be some sort of platformer with as much physics as I can cram into it.

Currently all the character physics are done, including horizontal acceleration and deceleration due to friction, collision/momentum with walls, jumping (use 2nd) with real gravity and such.

Next up is the scrolling tilemapper... I'm planning to use the tilemapper only for drawing, and not for collision detection. Hooray for inefficiency