API Groups

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!