When it comes to developing a good, full-fledged application or game, the best possible starting point is to get an existing tutorial or sample application (bundled with SDK) and rework/complete it with desired features. While implementing desired functionality, you may want to consult the page you're reading now. The following API Groups list structures, functions, defines, and global variables by categories. Please note that many important structures have large sets of methods which you could browse by following a link to respective structure. Most important structures are mentioned in the descriptions of corresponding groups.

System

Processes and Modules

These structures and functions are used to control the application as a whole. You may want to look at cWinApp and module_t structures.

Synchronization

Synchronization objects are used to synchronize access to shared objects. In many cases, you can use the Mutex structure.

Memory Management

CyOS routines you can use to allocate, manipulate and free memory.

Time-related

Some functions for setting and changing the date and time. Please look at the Time structure.

Sound, Music and Vibration

These structures are used to control sound, music and vibration in the Cybiko computer. Most music control methods can be found within the description of the MSequence structure.

Communications

Messaging

These functions and structures are used to send messages between applications, including those running on different Cybiko computers. You may also want to examine the Message and Buffer structures.

Selecting Remote Partners

These structures allow the user to find a partner for a multiplayer game.

Finder-related

With these structures, you can gather information about the Cy-environment (that is, the other people and Cybiko computers in the vicinity). Finder is probably the most important of these structures.

Low Level

Some low level communication functions. Don't use these functions if you don't know exactly what are you doing.

Graphics

Drawing Primitives and Screen Manipulation

These structures and functions are used for drawing various graphical primitives and displaying them onscreen. Please pay special attention to the DisplayGraphics and Graphics structures.

Bitmaps and Bitmap Sequences

The Bitmap structure is used for work with a single bitmap, while the BitmapSequence is used for work with a Bitmap array. (see Bitmap and BitmapSequence).

3D Graphics

These functions implement Wolfenstein3D/Ultima Underworld style graphics -- they simplify creation of your own 3D worlds. Please, pay special attention to the cy3d_draw_sprite() and cy3d_draw_wall() functions.

Fonts and Text

Some structures for work with text (please pay attention to Font structure).

Interface Elements

Application

These structures represent applications' major building blocks. In fact, your application is an instance of cWinApp (please note that module_t structure contains m_process field that is a pointer to 'your' instance), which is important, since it allows for the usage of forms, controls, as well as other interface elements.

Base Structures

The most basic structures (cObject, cClip, etc.) that serve as a base for the rest of this group, save the AppGeneric and the cWinApp structures. Please pay special attention to the cEngine structure that provides a couple of quite useful services (also, note that there exists a single, unique instance of such an object in the system).

Forms & Containers

Forms (cCustomForm, cFrameForm) are structures that can be used as containers that 'host' other elements, such as controls (see below). Please note that cDialog is a ready-to-use thing, you just have to provide its constructor with flags (there are about 40 bit masks for your convenience, so the whole thing is highly configurable).

Controls

This section groups standard controls found on many systems, such as cList (a list of selectable strings), cButton (a button with associated text and return value), cEdit (textual entry field), etc. These controls could be attached to the above described forms. Please note that cDialog is nothing else but a cCustomForm with several controls attached to it, according to the flags (its 'style') you pass to its constructor.

Built-in String Constants

String constants that are instantly usable from within your application or game.

Input and Output

File I/O

Structures of the File I/O section define the most basic file operations in the CyOS. Please look at Archive, FileInput, FileOutput and FileFind structures.

Keyboard Input

Some structures, functions and defines for work with keyboard. We recommend that you look at DirectKeyboard structure. It's more difficult, but it's a more effective way to handle keyboard input (the easy way is to just process respective Message's).

Serial Port Access

Functions for working with com port. Please see the respective Accessing Serial Port tutorials.

Formatted Output

With the help of these functions you can output data to either console or string buffer.

Utilities

String Manipulation

Some functions for string manipulations. Among these functions you can find ANSI C compatible ones (like strcpy(), strcmp() and others) as well as and functions specific to CyOS (is_pattern(), trunc_spaces(), strends()).

Conversion Routines

These functions are used to convert values from one format to another. Please make special note of cyid2str() and str2cyid(), because they can help to convert CyID to string and vice versa.

Integer Math

Here you can find some mathematical functions, imin() and imax() among them. If you need to find the minimal or maximal of two numbers, look at these efficient functions.

Vararg Functions

Some functions for handling variable numbers of arguments (like those in stdarg.h).

Miscellaneous

Structures and functions that don't fit anywhere else. By using Score structure methods, you make your game players' results available for upload to the Cybiko site. Thus, your game becomes contest-enabled!