Airio LFS Tracker
Admin's Manual (v. 2.0)

Airio Home Overview Downloads Changelog
User Manual Admin Manual Full Manual Airio FAQ
Airio Servers Live for Speed LFS Forum Donations

Contents

Introduction
What It Is
What It Isn't
Limad Commands
Limad Rights
Restrictive Commands
Management Commands
Control Messages
Control Commands
Server Commands
Admin Commands
Statistics Commands
Configuration Commands
Run Commands
Other Commands
Running Airio
Requirements
Airio Basic Files
Airio Configuration Files
Airio Support Files
Configuring Airio
Must Set
Should Set
May Set
Statistics Files
Closing Notes

Introduction

This document builds on the User Manual and expects some practical experience with Airio tracker from user's perspective. It first shows limad (see below for the meaning of this strange word) and admin commands, then moves on to explaining configuration and some internal workings of the application. It also tells what files Airio uses and what are the requirements of the application.

What It Is

Let me just summarize what Airio is:

  • A tool designed to connect to a dedicated LFS server (or more servers).
  • It watches everything happening on the server.
  • It manages races and may provide serious racing environment.
  • It follows players and keeps extensive stats.
  • It may report many things to users and admins.
  • It may restrict people's actions on the server.
  • It offers extensive customization options to players.
  • It gives admins have more than 100 configurable items.
  • It may provide PB file compatible with LFS Lapper.

What It Isn't

I may as well mention a few things that Airio is not, at least not currently:

  • It is not a lapper to be used on non-dedicated server.
  • Currently its use in single player mode is not supported.
  • It does not support cruising principles.
  • At present it does not support racing with AIs.

Limad Commands

Admin is a person that has connected to a LFS server with server admin password or is working on a dedicated server console. Admin has absolute control over the server and Airio offers him/her special management and control commands. Limad stands for limited admin (rights). Limads connect to server as normal players (without server password) but Airio assigns them special status based on their username so that they have some server commands available – they may e.g. spectate or kick people, depending on other settings.

Limad Rights

Limad usernames are stored in Airio.cfg.nc.txt file and can be easily updated. Limad status can thus be at any time granted or revoked. FREE version of Airio supports 2 levels of limad rights. People with Level 0 can only use any of the defined prohibited names and this arrangement is great for team members, once team tag is defined as (part of) a prohibited name. Level 2 limads have actually special commands available allowing them to a certain extent manage the server and the races, of which the most important is the ability to ban and kick anyone currently connected. Airio FULL version supports two additional limad levels, numbered 1 and 3. The commands available to every limad level can be fine-tuned in Airio.cfg.lc.txt file.

Once a player is recognized as a limad of sufficient level, he is presented with a message specifying how to get list of newly available commands – by typing !lhelp1 resp. !lhelp2 or just !l1 resp. !l2 (note that the letter is lowercase L). From the list, which respects limad level of the caller and shows only the items he can really use, it is clear that most of the commands also have shorter versions available. Limad commands are just like normal Airio commands – always starting with exclamation point (!) and hidden from view so that no one else sees actions of limad (anonymity guaranteed). Only users with limad or admin status can execute these commands, for other users they are ignored. Some of these commands just mimic those by default available to admins but others can be helpful even to people with full control over the server because they are shorter or a bit advanced versions of the general server (/) commands.

Limads of different levels can also have special privileges on the server, again according to adjustable settings inside Airio.cfg.lc.txt file. Final note before jumping to usable commands: Higher limads rule over the lower ones, meaning they may e.g. kick them. A limad cannot rule over people of the same class or higher, with the effect he can never kick e.g. admins nor himself. Such commands are simply ignored. Limad and admin commands and messages are not adjustable nor localizable; they are hard coded and always in Airio original language, English.

Restrictive Commands

These commands give limads direct control over connected people.

Note concerning nicknames: Nicknames and usernames in the following commands must be (for safety reasons) full (colour codes not necessary), or Airio will report no such person connected. Because some nicknames are hard to retype, here are two tricks how to make it easy: 1) Press Ctrl+Shift which shows usernames in all tables (race results, connection list, above cars). Read the username and retype it, this is usually easy. 2) Right-click on the person's nickname (or username, while holding Ctrl+Shift) in the connection table (displayed by pressing N, maybe twice). Text box appears with the name. Just jump before the name by pressing Home on keyboard and type "!ban " (including space) or other command, press Enter and you are done.

!ban name

This entry calls the /ban command, passing required parameters, and in effect bans anyone currently connected for the default value of 12 hours. The name is either full nickname or full username of someone currently connected.

  • !ban thenuisance – if that player is connected, it will convert his nickname to username and ban him for 12 hours. If no one with that nickname or username is connected, error info is shown and the command does nothing.

!kick name

Only one parameter is required representing full nickname or username of the player to be kicked from server. Nickname is internally converted to username which is then used for the actual kick. In case the specified nickname or username is not found, it is reported as error and no action is taken. For safety the nickname must be full and not just partial, even though that would also be possible. This command may be used by limads to get rid of people spoiling the races or otherwise behaving inappropriately. Admins may use it if they don't want to search for player's username when issuing /kick command remotely.

  • !kick thecrasher – kicks person with that username or nickname from the server.

Alternative version: !kk.

!spec name

This command has the same format as the previous one, only just spectates the player by his full nickname using server /spec command. It could be used as an indirect warning or in case the player is blocking the road and automated spectating (by default after 30 seconds) by Airio in race is just too slow. It may also be handy for people ignoring blue flags.

  • !spec theobstacle – spectates person with that username or nickname.

If you see a "Parameter not valid" message after issuing the !spec command, it means the player is not currently on track (already spectating). In case the specified nickname is not found, it is reported as error and no action is taken.

Alternative version: !se.

!pit name

As a variation of the above commands, this one returns specified player to pitlane using server /pitlane command. It again could be used as an indirect warning or in case the player is blocking the road.

  • !pit thedisrespectful – sends person with that username or nickname to pitlane.

!pen 30|45|dt|sg|cl name

Last of the control or restrictive command allows giving/clearing penalties. You must always specify penalty type and the nickname or username. 30 and 45 are seconds, DT is drive-through, SG is stop-and-go, and CL means clearing any currently active penalty of that player.

  • !pen 45 amistake – gives 45 seconds penalty to the user.
  • !pen cl amistake – clears the previously given penalty.

Management Commands

Limads must be able to control the races, though in a limited fashion. They also have other commands at their disposal showing details about players.

!restart, !qualify, !end

Very useful commands allowing limads to restart the race at any time, start qualification session and end current race. By default Airio blocks race restart voting once the race first lap is completed (with some exceptions, like when there are only a few people racing or the race takes too long). The !restart command will overcome the limitation and immediately restart the race. It just calls /restart. Note again that the mentioned default race restart voting restriction (only in lap 1) is freely configurable. The other commands just call /qualify resp. /end LFS server commands.

Alternative versions: !re, !qu.

!ax [i|o|e|a] [layout]

When used with i switch it will list layouts for current track available on the server. Any of them can then be loaded using o switch. Loaded layout is cleared with e switch. You may set autocross lap count using the a switch.

!players

This command shows connected players' status describing admin/limad, licence and some car settings plus lagging. There's nickname and username together with his limad/admin status (if any). Then follows guessed demo/licensed status of that player based on number of items in his personal LFSW data. Note that it is not directly possible to get information about licences (Demo, S1, S2) of individual connected players and their licence status may not be always shown correctly, as in case of person that is new to S1/2 and did not make any laps (or deleted that data) on more combinations than available in demo. Once LFSW PubStats offer this information (feature request already posted), the code will be updated.

What follows are info about car settings he is using like brake help, automatic clutch, mouse/wheel, ABS and similar data. The line ends with a number representing lagging percentage, which should be as close to zero as possible. Lagging is observed only during races, not in practice or qualification. Experience shows that lagging close to 1 percent is very inconvenient for other people, because that car is disappearing or jumping wildly around the track. People close to 1 percent of missing car position packets (which is lagging) are likely to be often spectated or later kicked under default lagging filter setting.

Alternative versions: !pl.

!recent

Very useful command showing the list of 12 recently disconnected (for any reason – kick, security, disconnect) people, their nicknames and usernames. This is very handy if someone causes a big crash and then quickly disconnects. If you did not catch the crasher's registered username but still need to ban him, just call this command and use the displayed data. But also note that only limads level 3 (available in FULL Airio version) and admins may ban unconnected people.

Alternative versions: !rt.

Control Messages

Race control messages displayed with simpler commands and disappearing automatically after a set time may also be useful for both limads and admins.

!rc [message]

RC stands for Race Control (message) and it allows limads and admins to set and show the messages that appear in big letters in the middle of the screen. Actions of this command depend on what parameters are specified. Calling !rc without parameters just clears all earlier sent messages that are currently displayed. If some text follows the !rc, this command takes the message and stores it for later display. The message is not shown to anyone immediately – for that other forms of the !rc command are necessary.

  • !rc All crashers leave! – stores the message to be shown later.
  • !rc – clears any displayed messages, if the timer (see next) did not clear them earlier.

Just note that the message must not start with a number that could be misinterpreted as display time (see below). Setting the message as "5 minutes break now" would not do what you expect – it would try to display some previously stored message to person called "minutes break now" for 5 seconds, and this act will fail miserably. The parameter "Now 5 minutes break" is correctly interpreted as new message to be shown by the next command.

!rc time [name]

When an integer (delimited by spaces) is seen after the !rc command, it is interpreted as the time span in seconds for which the previously stored message should be shown. When no name is specified the message is displayed to everyone connected. If you want the message to be shown for some not yet specified time, enter !rc 999 or use even higher number. You can clear that message any time by issuing simple !rc command without parameters.

If you want the message to be sent to some particular player, specify both time and full nickname. You cannot send RC messages to spectating players, only to players on track. If the entered nickname does not exist (or the player is not on track), you'll see "Parameter is not valid" system message. Note that if you just want to change some already displayed message, you must first define a new one and then send it again.

  • !rc 10 – shows the previously stored message to everyone for 10 seconds, then clears it automatically.
  • !rc 999 youthere – shows the message only to this person for a rather long time.

Control Commands

Another group of limad/admin commands controls Airio state with substantial impact in many areas. They should be available only to highest limads (level 3 in FULL version) and admins, because of the potential damage they may cause.

!checks [on|off]

This command turns on (default state) and off all active additional Airio checks like idling, cursing, wrong way driving, repeated joining etc. If these checks are turned off Airio just tracks and displays statistics (split/sector/lap times) of every player and race as a whole. This mode is useful for some special occasions like having a closed race for invited people only when it is clear that everyone is interested in nice racing and the checks could have negative impact – e.g. spectating a player that just needs long time to get off the gravel. Turning off checks is also necessary for some layout configurations and stunt racing. If neither on nor off is specified, this command shows current Airio state. Using the !cfg command and knowing configuration keys it is also possible to turn on and off individual checks (see user manual for their list) as well as other externally defined settings.

Alternative versions: !ch.

!lock [per]|[on|off|auto]

By this command it is possible to lock or unlock the server for newcomers, players that did not yet score some definable reasonable time, either on your server or on any server if LFSW stats are available. The !lock command does not make the server private, it just does not allow anyone without reasonable PB data to join the race. Such a player is required to leave while newly connecting players with recorded good lap times (by default 1.05 x WR for current track and selected car) may freely join. The command without parameters displays current server time lock state.

The command may be used to ensure nice racing without "moving obstacles" on track once the user base is large enough. It complements special Airio settings allowing to define "prime time" when the server will lock and unlock automatically. These setting allow you to define required lap time, start and end of the prime server usage period and also number of players when the lock is activated and deactivated. For more information see the server configuration file (SRV). A few examples now will hopefully make clear what the options are.

  • !lock on – just turns on the lock under current settings and displays lap time of default car needed to join the race. The lock will stay active regardless of other circumstances.
  • !lock off – turns the lock off and the time lock remains off regardless of detailed prime time settings in server configuration file.
  • !lock auto – switches the time lock function into automatic mode, running according to detailed configuration data, switching it on and off as required.
  • !lock 450 – sets the time required for joining race to 4.50 percent above current WR in the car the player intends to use. Real time for default car is displayed for your information. Note that for the sake of flexibility the time will be not rounded to some nice value. If you want exact number, try using different percentage values. The lock mode on/off/auto is not changed by this version of the command, only the percentage value changes.

Alternative versions: !lk.

!grp [num]

This is a command for grouping races into series (5 races are 1 serie, by default). If used without parameter, it clears the current serie data, starting a new round. When a number is specified, current serie is cleared and new one with the set number of races started.

  • !grp – clears current serie, starts a new one without changing the number of races.
  • !grp 2 – clears current serie, starts a new one for two races.

!len [–96÷+96]

This command accepts values from –96 to +96. It is used for setting up race length. Positive values are simply laps to be done. Using zero turns the server into practice mode. Using negative values sets race length in minutes. The race is then for set number of minutes plus one lap. This nice feature uses a little trick: By specifying negative value you in fact set racing for that number of hours, but Airio is checking the elapsed time whenever leader enters new lap and once the total time in minutes is larger than race length in hours, one more lap is added and race is turned into normal one for set number of laps.

  • !len 5 – race length will be set to 5 laps.
  • !len -25 – the race will be for 25 minutes plus one lap, confirmed by race control message at the start.

To switch between races for minutes and laps you must use this command. Specifying simply /laps=5 after race for minutes will not suffice, because Airio must renew last used minute setting just before the race start and it will ignore currently specified number of laps.

!pall, !sall

These simple commands send all cars to pits or among spectators. You may use the global spectating after race when some changes in configuration need to be reapplied. For example car tyres are checked only when a player is joining race, not later. This means if you prohibit his tyre type later and type !rld, he will stay on track with disallowed tyres. Typing !sall spectates all people, forcing them to join again, with all the joining checks now using updated values. The !pall command just calls /pit_all.

Alternative version: !sa.

Server Commands

It is possible to assign to limad categories other commands mimicking those of LFS server itself. These commands have the same format as the LFS original, only start with ! instead of /. Currently the following commands are supported: !tracks (sent as /track for collision reasons), !cars, !weather, !wind, !laps, !hours, !qual, !vote, !midrace, !mustpit, !canreset, !msg, !pass. Parameters are passed just as received, no validity checks are done. See LFS documentation for meanings of the mentioned commands. All these commands can be found with short explanations and possible parameters in !l3 output.

Admin Commands

Every player connected as an admin sees not only the user welcome message, but also instructions how to display list of limad command (see previous section) and admin commands – by typing !ahelp or just !a. These commands have great power and can cause troubles, so please be very careful and think twice before sending them to Airio for processing.

Statistics Commands

First group of commands basically allow some manipulation with PB files.

!remove [car|*] [track|*]

This command removes all stats for certain tracks and/or cars. It allows you to delete e.g. all data for FBM on BL1, or all data for FBM on all tracks (denoted by *), or all cars (also specified as *) on BL1, and also all cars on all tracks. It is clear this command is very dangerous and must be used with extreme caution. It is reversible only by stopping Airio, rewriting STA files from latest backup and starting Airio again.

  • !remove – deletes all gathered stats on your current track and your current car.
  • !remove * FE6 – deletes stored statistics for all cars on FE6.
  • !remove RB4 * – deletes all peoples' RB4 stats on all tracks.
  • !remove * * – erases all stored PB data, the Airio.sta.cr.txt file with car-level data (split/sector times) will be empty.
  • !remove BL1 * – ERROR, 1st parameter must be car code.

Alternative versions: !rem.

!delete [car|*|**] name

This command deletes player's stats from PB file. The deleted data cannot be automatically recovered, so one needs to be careful with this command. The command always expects player's full username as a parameter. Optionally it is possible to set also car for which the player stats should be erased. If car is not specifies, your current car is used. Before issuing this command it is advised to use !pb command with the same format. Once it returns correct data that are to be deleted, you may just replace !pb with !delete.

It is also possible to delete player's stats not only for current car, but for all cars on current track. In that case use * as car code. If you are really angry at someone, you may delete all his stored stats for all tracks and all cars. Just use ** as car code, but make really sure you are entering the correct username.

  • !delete thehacker – deletes the player's statistics for the current track and the car you are in.
  • !delete * thehacker – deletes the player's statistics for the current track and all cars he ever used on your server.
  • !delete ** thehacker – removes all this player's statistics from your server, keeping only his personal setting.

Output of the command summarizes what was actually deleted, but the action is not reversible, unless you stop Airio, replace SAT files from backup and start Airio again.

Alternative versions: !del.

!clr [t|c]

This is one more command to manipulate with statistics. It clears temporary data stored on two levels called total and championship. They are definable periods for which some racing data (lap times, race times, points) are updated and then automatically deleted. Using the t switch will delete all temporary data at total level, c switch does the same for championship level. Routines of this command may be called automatically by setting specific values in days in common configuration file. For more on this see the configuration section. Output of the command says what level of temporary data was deleted.

Configuration Commands

!state [num]

If you are interested in current server state, call this command. It will show you not only the server name, but also race type (laps, hours), value (number of laps or hours) and other server data like number of connections and players, wind, weather, allowed voting, midrace join, active Airio checks and server time lock, among others. If Airio is connected to several servers, you may call up the state of any one of them using the internal number. If 0 is specified, summary of all servers with short state descriptions is displayed.

Alternative versions: !st.

!reload

This very useful command allows to update all configuration data without restarting Airio. There are several external text files that are read on Airio initialization. If some data need to be updated (e.g. add new word to curse list, define new limad username, or update speedtrap position, see below), it may be done by direct editing of these files on the server (or overwriting them with new versions). Saved changes are not updated automatically – but you can require immediate update of the information by issuing !rld command. All external configuration files (except CON and STA files) will be read once again and new settings will be valid from this moment. Just note that for a limad status to be applied to currently connected player he must reconnect (because it is assigned only on connecting).

Alternative versions: !rld.

!cfg key=value

In the common and server configuration files the entries are specified using key=value pairs. The !cfg command allows you to enter any such item and its assigned value manually. You could do the same by opening the appropriate configuration file, updating a value there, saving the file and using !rld command to apply the changes. However, if you do not have time for his procedure, you can use the !cfg command for temporary changes. They are temporary, because they are only in memory and if you reload configuration files later, the data specified there will be again valid. If you want to use this command, you need to be aware of the key you need and accepted values. Once you get these two items in the correct form, Airio will confirm accepting the new temporary value.

Run Commands

Airio is run by simple opening of its main EXE file. It reads available configuration files (see below) and tries to connect to servers according to specified settings. After connecting successfully to a server it performs initialization and lets everyone know it is now in charge. There are additional commands controlling run of the application and connection to LFS servers.

!aini

This command cleanly restarts the Airio tracker. It may be used in a situating when an internal error occurred and some commands do not provide correct output, if any at all. The Airio tracker is stopped on all connected servers, data saved and then a new instance for each server is created. Airio starts gathering new data and for a minute or two it may report slightly strange data, like very high split times as best in the race etc. This is normal start-up behaviour.

As noted earlier (and explained in detail later) one running instance of the Airio tracker can easily manage and control several LFS servers at the same time. This arrangement saves resources, simplifies configuration and allows for some advanced features like having one common communication thread for all LFSW PubStats requests and one common data repository with new PBs on one server immediately available on all the remaining servers. The !init command reinitializes Airio on all configured servers, not only on the server where it was actually issued.

Alternative versions: !ai.

!quit

This command cleanly closes the Airio tracker. It means that all current data are stored, all opened connections closed and all used resources properly freed. Always use this command to stop Airio – the same may be done by pressing Q in the command console seen on server. Direct killing of the process may have undesirable side effects – damaged PB files, incomplete system log file etc. The command actually does not end Airio process, only stops all data processing and moves it into suspended state from which it can be safely killed. On server console killing is not necessary, one more press of Q closes Airio completely. Note that once Airio is in suspended mode, it may only be closed as it does not accept any commands and does no processing. Also note that like in the previous case the !quit command closes Airio on all connected servers, not only on the current one.

Alternative versions: !qt.

!join num

When something goes wrong with LFS server itself, Airio disconnects from it. Then it tries to reconnect every 5 minutes, indefinitely. If you cannot wait this long, use the !join command for manual reconnection with appropriate server number. Airio will inform you after a while if the connection succeeded or not. This command may also be used when adding new server to be managed by a running Airio instance. I may hint here on the procedure, because it is pretty simple: Just put new Airio.con.?.txt file containing required connection data into Airio folder (? here represents unique server number). Again, Airio would connect and start managing the new server automatically within 5 minutes, but you may gain a bit of time by requiring the connection manually.

Alternative versions: !jo.

!part num

Naturally, this is the opposite of the previous command, allowing you to disconnect Airio from any server, and only from that one. As mentioned, Airio would under normal circumstances try to connect back within 5 minutes, so there's a little trick to prevent that: The appropriate Airio.con.?.txt file is renamed, so that Airio would lose necessary connection data. When you finish the server maintenance or solve whatever reasons you had for disconnecting Airio from that server, you may just use the !join command which will rename the CON file back and use it for connecting. However, you may also rename the CON file manually and wait a while for automatic reconnect.

Alternative versions: !pa.

Other Commands

!log

This admin command copies to the chat console in real time entries (pertaining to current server or Airio instance as a whole) being saved into system log file. It is great far watching some internal Airio events and detailed info about actions it takes (e.g. why someone was spectated or kicked). There can be only one system log redirection for all connected servers at one time. Issuing the command by another admin or on another server cancels the previous target and assigns new target. Once the command is issued from current redirection target the messages stop. The same happens if the target is lost (disconnected), but it is always better to turn off the log messages manually.

Lets make it clear: First !log entry turn on log display and on any decently used server you'll be flooded with log data. Using !log again stops displaying the log entries. Watching the lines appearing will give you a good understanding of Airio and the LFS server internal workings and events that are captured. To get a bit deeper understanding of the info you see check out the system log file description below.

!imp

This command without parameters imports data from LFS Lapper's PB.txt file and converts them into Airio format. You may use it just once when switching from LFS Lapper to Airio to import all previously saved stats in the extent LFS Lapper allows. The import rewrites current Airio data and thus it is not recommended to call it later, after some data were accumulated by Airio itself, because that operation will result in data loss. The PB.txt file is expected to be in Airio directory.

When importing the data Airio by default checks everything. Unfortunately LFS Lapper's file may contain wrong information, such as missing car types or sector times close to zero. During import all unrealistic or incomplete items will be removed, just as items exceeding set statistics limit time (100 percent of WR by default). This all helps to start with clean and reasonable imported stats.

!exp

As you may expect, this command does the opposite of the previous one, exporting Airio data into LFS Lapper PB.txt file. You may use it when switching from Airio to LFS Lapper but it also can be used if you need the Lapper file for some other reason like publishing Web stats using a custom-built PHP script. Naturally, you may create a new script reading directly Airio STA files – if you want to do this (and perhaps make the script publicly available), contact me and ask about STA files format. Just know that STA format is more complicated with data spread hierarchically across three of four separate files. You should also note the possibility to require automatic export to PB.txt in set intervals. With that arrangement you will always have reasonably up-to-date personal best data in LFS Lapper format to work with. For more info see the common configuration file (CFG).

Running Airio

We have gone through all the commands, it is now time to turn our attention to Airio itself. This section explains what is needed to run the application, how to run it and what files it uses.

Airio Requirements

Software

To use Airio your system must meet certain requirements:

  • Airio is written in C# and it requires .NET Framework 2.0 or newer installed. If your PC can run this framework, then Airio will run as well. It has been fully tested under Windows XP and Windows 2003. Also the possibility to run it reliably under Mono in Linux is now confirmed from several sources (you need to install mono-runtime, libmono-corlib2.0-cil, and libmono-system2.0-cil).
  • Airio can correctly connect only to a dedicated LFS server. It is a server management tool and currently it will behave strangely if used in single-player mode or when connected directly to LFS game. The dedicated server must also run with system messages in English for some cool features to function, but I'm not sure if this is in fact configurable.

Hardware

Here I'll try to summarize the Airio hardware requirements:

  • The application just waits most of the time for some events to process and thus it is not much CPU-dependent. On a PM 2GHz machine it was on average consuming at maximum 5 to 10 percent of the CPU capacity with four servers and 40 connected users managed at the same. There may be some peaks in the usage when long lists of several thousands users are sorted (outputs of !sb or !pm) or repeatedly searched. Generally any reasonable processor, say 1GHz (but slower would suffice as well) can power Airio.
  • Airio memory requirements for managing users and storing their data are not huge. Airio requires maximum 30 or 40 MB of system memory for four concurrently managed servers – most of it for the .NET environment.
  • Disk space requirements are in units of megabytes and thus negligible.
  • All communication with the LFS server(s) is done using TCP, so you need a computer (or connection) where that protocol runs smoothly and reliably.

Communication

To use all available features some external communication is required:

  • If you want to have LFS World data available, you must create and use a PubStats key (see configuration section). Once that key is set, Airio will require some data from LFS World. By default it downloads compete WR (world record) table once an hour. It also requests and downloads complete PB (personal best) table of everyone connected to server. This table is downloaded again when that person improves one of his LFSW PBs.
  • By default Airio sends each minute summarized data from servers it is connected to, the so-called local stats. They are primarily version string, names of the servers, total number of servers, connections, and number of players of that one Airio instance. These data are used in global stats calculations with results sent back to Airio. You can see the data returned in !ver (or !info) command output. Anyone thus may see how many Airio instances are running and how many servers and people they currently manage. The sent local stats are handled by an ASP.NET script/page allowing anyone to see all currently running Airio instances and managed servers. Just browse to Airio Servers page.

The above are the only external communications taking place in FREE version of Airio. The protocol used is TCP and you may need to make sure such requests from Airio and responses are supported in your computer connection configuration (firewalls, communication shields).

Transferred LFSW data volume depends on the server(s) usage. The more people are connecting, the more data are downloaded. For example WR table represents approximately 40 KB (kilobytes) of data. People's PB tables may have size from 1 KB to 50 KB. Generally speaking, these bandwidth requirements are not high, especially in comparison with data sent and received by LFS server itself about people's cars and other events.

Local/global stats are sent and received once every minute. Depending on number of servers each request (local stats) will represent 30 to 100 B (bytes) of data. The response is approximately 30 B. It is obvious that communication requirements of this feature are rather negligible – unless you have a compelling reason to do so, please do not turn off sending Airio local stats (but note that you have the option). This will make sure the displayed data are meaningful to you and all other Airio users.

Airio Basic Files

The Airio archive available for download contains a number of files. Some of them are required for the application to run, some allow you to change configuration options, some are created automatically, and yet other you may create yourself. All the Airio files are in one folder (directory), there are no subdirectories. Unzip the files to a new folder on your computer, ideally on the machine where your LFS server(s) run. Lets look now at the files and their purpose.

Required

These files are necessary for running the application. If some of them is missing, then Airio will not start, it will shut itself down or report errors soon.

  • Airio.exe – Naturally, this is the main application file, the one you run when you did some basic configuration and are trying to connect the system to your server(s). Airio is a console application and the best way to start it is by double-clicking on Airio.exe file. Hint: Try pressing spacebar in the Airio console window. You'll see a list of commands called by pressing other specific keys – showing state of server(s), connected people or players, all this in nice textual tables.
  • Airio.pdb – This is a debug file of the main application. If there is some bug in the code, extensive error data are saved into Airio log file allowing for easy debugging.
  • Airio.wrs.txt – Current world records table. The data stored there are important for many internal Airio calculations and without this file Airio refuses to start. It is best if the file is updated automatically every hour; it is admin responsibility to configure Airio in such a way (see the configuration section).

Connection

The most important of configuration file(s) are the connection data, CON. Each server has its own CON file with all necessary data. The CON file also specifies in its name the server number as used internally by Airio.

  • Airio.con.?.txt – Connection file specifying LFS server to connect to. IP address of the server (may be local, 127.0.0.1), InSim port (as defined in server configuration file or by /insim command, usually around 30000), and server password must always be set inside the file. The ? in filename represents unique server number used internally by Airio and must be from 1 to 4, numbering the servers somehow logically to you. There are other files and commands using this server number, so you should know which server has what number. Once again, because this is very important: You set server number by the filename, inside the CON file you then specify connection to the server.

When Airio starts it reads in sequence all existing CON files with numbers from 0 (reserved for local testing) to 4 (but this may be anything higher in FULL version), if they exist. Based on the data it tries to create connection according to stored configuration data. If it succeeds, new handler is created, initialized and starts gathering the information and acting upon it. If connection for some reason fails then that server is simply skipped and next one is processed. This allows for any combination of servers to be active. These configuration files are read only when Airio starts, is restarting after !aini command or reconnecting to some server automatically or manually by !join. This is the time when any changes to Airio.con.?.txt files are reflected.

Airio Configuration Files

In the following files you configure various settings applied generally or to individual servers.

Common Configuration

Besides CON file(s) the other configuration files are not necessary for the application to run but they allow you to change Airio default values in many aspects. Lets look now at the common configuration, CFG, files.

  • Airio.cfg.txt – Common general configuration file. Inside you'll find setting used by all managed LFS servers. There are non-server specific data like IdentKey for LFS World downloads, logging, defining cars and tracks and such. Open the file, read the extensive comments there concerning individual items, change or update what is necessary. Find out more info about values you should change before running Airio for the first time below in the configuration section of this document.
  • Airio.cfg.tc.txt – Common (to all connected servers) track and car configuration file. Here you can define default cars (which are assigned to every new connection before the player joins the race) for specific tracks, times considered and optionally reported as good, prohibited tyres, prohibited passengers, restricted zones and similar items. The file has hierarchic structure and contains some default demo tracks/cars settings and explanation of all usable items.
  • Airio.cfg.nc.txt – Common name/language filter configuration file. Inside you can define two categories of names: 1) usernames of limads that get special rights after connecting and 2) prohibited (parts of) names, for which players are kicked. Read above what limad is. This file also contains definitions of language filter consisting of three parts: 1) character replacements applied first, 2) the bad words themselves, and 3) exceptions to bad words. Again see the comments inside the file to get more detailed information.
  • Airio.cfg.lc.txt – Common limad/commands configuration file. While limads themselves and their categories are set in Airio.cfg.nc.txt, items in this file allow you to fine-tune commands actually available to limads by their levels. You may also choose the level of protection limads gain and set the system so that they are never kicked (which looks bad) or are able to breach certain rules.

Server Configuration

Common configuration is applied unchangeably to all servers in the site (managed by one running Airio instance). Server configuration files, SRV and FIL, contain items that can be adjusted on individual servers. These servers are set by numbers corresponding to numbers used in names of CON files

  • Airio.srv.txt – This is the general server configuration file. The settings inside are by default applied to all servers in the site, but any value can be changed on any server. This file offers many options, with every one explained in detail using comments (starting with #). Inside you'll find optional message definitions, vote management data, server locking, points and other items.
  • Airio.fil.txt - Inside are various filter settings. They may be also in SRV files and this special filter configuration file was created only because it helps to separate items logically and to have two smaller files instead of one large file.
  • Airio.srv.?.txt – This file configures only server ?, which is the number corresponding to particular CON filename and real server defined inside. In this file you may use any key from Airio.srv.txt and assign it a different value, overwriting (and in case of messages extending) the general configuration with more specific data.
  • Airio.fil.?.txt - Definitions of filters for individual servers, if they should differ from values in the main FIL file. You may also include these items in Airio.srv.?.txt file, if there are just a few changes.

Once you understand the principle of server configuration, you will realize it is versatile, live, and hierarchic. By versatile I mean it gives you many options. It will also be easy to add new options later, because it just means creating new key=value pairs. By live I mean anything can be updated (by editing the CFG or SRV file) while Airio is running and applied without restart (by calling !rld). This reloads all external configuration files and updates internal settings accordingly, without players realizing this was done. By hierarchic I mean the config data are on three levels: There is common configuration CFG, there is general server configuration SRV/FIL and there is specific server configuration.

Worth mentioning again is the !cfg command. Using !cfg key=value you may temporarily change any item from the config files. The exception are items from CFG.TC and CFG.NC files which cannot be updated in his fashion. Final note: Server configuration files are read in the above shown order with the last defined value applied. This means that when you have the same key but different value in Airio.fil.txt and Airio.srv.1.txt file, the one from server-specific file will be used.

Language Files

One of the coolest Airio features is the ability to fully customize and localize all user messages. Lets take a look at what you can have and what can be done.

  • Airio.msg.en.txt – This file contains definitions of all Airio user messages. These are lines of textual information that can be seen by normal users. You can change the text of any message you do not like, but please make sure it is still understandable. Note that limad and admin messages cannot be changed, they are hard coded into the application and are always in English (well, as far as I'm able to write in that language).
  • Airio.msg.cz.txt – Localized user messages file. This file shows how easy it is to support more user languages in Airio with everyone able to select at any time a different language in which he wants to see the messages. The file contains complete Czech localization. Once you put the file into Airio folder (and type !rld, if the application is already running), a new language option will appear in user preferences and the language can be changed by a simple click.
  • Airio.msg.??.txt – In Airio distribution there may be other localized message files. These may also be available in the form of language pack available with latest additions/corrections on the Airio site. In any case, to have such translations available, just put the files into Airio folder and type !rld.

If you want to create other localizations, just copy the EN file, rename it e.g. to Airio.msg.fr.txt and translate all the values of key=value pairs. When you are done (which will take some time, because there are some 300 user messages defined), save the file into Airio folder, type !rld and immediately you'll see FR language as a new option.

You are not limited to translations when dealing with user messages. You may e.g. create an Airio.msg.ns.txt file and specify inside (one of the keys at the top) that this version is NASTY. It may still be English, but you'll adjust the messages in some "nasty" fashion. Just note there may be only 2 letters in the file name specifying (language, whatever) version.

Also note that it would be nice of you not to change the default English messages, because people may be used to them from other servers running Airio. Also there may appear new messages in future Airio version requiring you to overwrite the original file. Rather create a new language version in the manner I just mentioned. If some item is not specified, default message equal to official EN version will be used, so you may redefine just part of the file and delete the rest.

Airio Support Files

Statistic Files

Many data gathered by Airio are made persistent, that is saved to disk in regular intervals. They are the statistics of individual players, their personal settings, tracks/cars they used, lap/race times they achieved and many, many more. All the available stats are explained or mentioned in Airio User Manual. The stored data are in four STA files, again hierarchically arranged. Note that Airio distribution may come without STA files, in which case they are created as empty.

  • Airio.sta.un.txt – This file stores username, nickname, and personal settings of every player. If a player changes his nickname, it will be reflected in this file only. Username (registered at www.lfs.net) represents highest entity in Airio, everything revolves around usernames.
  • Airio.sta.tr.txt – This is a file of track statistics. It stores track-level data for each user, such as points and other total/champ level information. Track is the second level of the Airio internal hierarchy (remember that username is the first).
  • Airio.sta.cr.txt – Here is the 3rd level of the hierarchy, file of car statistics. Inside are car-level data for each user and track. These data are primarily best sector and split times, the core of !pb listings. There is also a date the PB was made and number of laps done by that player on this track and in this car.
  • Airio.sta.ac.txt – This file is on the same level as car stats, but it stores separately data from autocross layouts. Airio recognizes autocross layouts by their names and shows separate statistics for each of them, just like they were different tracks. Note that if you change layout name on server, Airio sees the layout as a new track and will start to gather new stats. If you on the other hand use different layout with the same name, Airio cannot see the difference and will start to update existing data.

Text Files

There are a few more text files allowing for some more customization and communication with users.

  • Airio.txt.fq.txt – You may optionally put into this file lines of text shown when a user clicks the Server FAQ button on the personal settings screen. Each line will be shown as one button, so you need to use lines of correct suitable length. Just save the file and click FAQ, no !rld is necessary here.
  • Airio.txt.nt.txt – Same as above but the text entered should contain Server Notes, if you can come up with any.
  • Airio.txt.rl.txt – Same as above but the text entered should contain Server Rules and you certainly should come up with some.
  • Airio.rep.txt – This file is created by !rep command and contains reports or comments sent to you by users. It is a good idea to check for presence of this file regularly and delete it once its items are dealt with.

System Log

The system log was already mentioned as a very interesting feature in the !log command. Basically it is a text file storing continuously all important events on all servers managed by Airio.

  • Airio.log – This is the record file used for all connected servers. When being backed-up (on server midnight, every day) this file is flushed and closed, copied as Airio.log.txt, and zipped together with other configuration files. The file is then rewritten and starts to store new day's system log data.
  • Airio.log.txt – As apparent from previous description, this file stores complete yesterday's system log. It is also included in back-up of the previous day.

Each line in the syslog file starts with server date and time. Then follows XXY where XX is short site identification and Y the server number (as set by connection files) where the action occurred. In case of some global action (like downloading WR table, common to all) there is no XXY tag. Then may follow a message exactly as seen in the LFS chat area (including system messages and players' commands). In case there is some Airio action, it start with CxxPyy where xx is connection ID and yy is player ID of a specific man. These are very important LFS data used extensively inside Airio. Then it is clear what action Airio took and why, like who was warned, spectated and kicked and for what (e.g. what word in his message was seen as cursing or how many times he was seen as driving wrong way). The log may be used for detailed analysis of events and their sequence. It notes when certain events happened and may give answers to many questions of "why this happened" type.

Configuring Airio

By now you should have a general idea concerning configuring and running Airio. Let me just repeat that all configuration is done using external text files and that anything configured may always be changed "live", without restarting Airio, just by issuing !rld command. This section looks in more detail at the settings you must, should and may configure before running Airio. Note that the configuration files contain lots of other settings not mentioned here, but each one with several lines of comment that makes its purpose clear.

Must Set

There are some changes you must do to get somewhere.

  • Open the Airio.con.1.txt file and define inside the connection to your LFS server number 1. IP address, InSim port and server password are the necessary data. The IP address may be local (default) or any other static address. Airio can connect to remote servers, but in that case there may be other configurations required on the target system, such as opening TCP ports or defining firewall exceptions. The InSim port number is specified inside LFS server configuration or by /insim command. Each server must have unique InSim port number, usually around 30000. The password is admin password set at LFS server. Airio is always connected with admin privileges to do its stuff.
  • If you want to connect one running instance of Airio to second server, copy the Airio.con.1.txt file and rename it to Airio.con.2.txt. Open the file and define there connection to your second server. FREE Airio version supports four connections (meaning you can also create files Airio.con.3.txt and Airio.con.4.txt), in the FULL version the number of servers is fully configurable and changeable parameter with upper limit set only by your computer's abilities.

Once you have connections defined, you may run Airio (by double clicking Airio.exe). It should start and connect in a short while sequentially to all defined servers. You can see in the application console to which servers it connected. If a connection cannot be established, check the data in the appropriate CON file, especially the InSim port and password. If you find out there was a mistake, correct it, save the file and then press R in the console window. This will restart Airio, read the CON files again and try to establish connections according to updated settings. If you want to stop Airio, press Q in the console. To see the available commands there press spacebar.

Should Set

While not absolutely necessary, it would be good to do a few more changes before you start Airio.

  • Inside the Airio.cfg.txt find a key labelled ServersID. As the comment there mentions, you set here a very short name of your server(s), say two or three capital letters. It may be a tag of your team or anything else but for the global statistic purposes (as shown with !ver command) use something unique. For example on AirAttack servers we use ServersID=AA. This tag is then used to shortly describe your servers in system log.
  • Still inside Airio.cfg.txt look for an item named IdentKey. This represents LFS World identification key you may generate for yourself. Go to www.lfsworld.net, open My LFSW Settings panel, click on Pubstat Access tab and generate an IdentKey value. Copy the value into the IdentKey item. If you do this, Airio may access LFSW data of individual players and it may also download WR table every hour. If using this service free of change, then LFSW requests are limited to one per 5 seconds. Airio will ensure this rule is observed. Note that you also have the option to pay for the service, which will give you all LFSW data instantaneously.
  • Now open the Airio.srv.txt file and find TextLogo key. This one represents text of your team/server as shown on every race start and in players' personal preferences screen. It would be a good idea to identify your site by defining this text. You may use standard LFS colour tags in the text (that is from ^0 for black to ^8 for gray). Once defined, this text will be shown on all your servers (together with standard Airio Powered tag in small letters).
  • If you want to have different TextLogo text shown on individual servers, you need to overwrite this general setting in server specific file. For example for your server 2 you need to open Airio.srv.2.txt file. (If that file does not exist, just create it by copying and renaming Airio.srv.1.txt.) Open the server 2 file and put inside TextLogo= together with new required server logo text. This setting will be applied only to the 2nd server, that is once you save/close the file and reload all configurations by typing !rld (or restart Airio, but that is really not necessary and not recommended).

If you complete all the above mentioned steps and run Airio, you will have somehow customized installation/setup providing all the core functionality and using most of the default settings.

May Set

Now it is time to go through the configuration files, read the comments and adjust any of the items if you think that is necessary. Here are just a few picks at the items you may update to suit your purposes:

Common Configuration

  • In Airio.cfg.txt you may define additional car groups (approximately equal cars for point system) under CarGroups. You may set MaxTime specifying in percents what lap time is needed in any track/car combination to get into server stored statistics. This setting helps ignore high lap times that would just clutter the system and are of no real value. By DaysChamp and DaysTotal you may define short-term and long-term temporary stats data (e.g. points).
  • If you need PB.txt file to work with using custom PHP scripts (for Web statistics), set up automatic generation and updating of such a file. In Airio.cfg.txt set ExportLapperData to true and use ExportLapperTime to specify update interval in minutes.
  • Put inside Airio.cfg.nc.txt the usernames of all people that should have higher rights and some level of protection on your servers. These people are set as Limad2 (have special commands available) or Limad0 (can use prohibited nickname, good for team members) with username following.
  • Check out Airio.cfg.lc.txt file contents and choose the commands that should be available to limads (starting with Enable). See also items starting with Allow and set actions for which limads and admins will not be spectated or kicked. Note that the default settings are reasonable so you may update the file only when really necessary, once you do not like the default options/behaviour.
  • Define absolute or relative good/great/top lap times for any track/car combination using items of the Airio.cfg.tc.txt file. Note that it is not possible to define absolute good/great/top split/sector times. These are always calculated from defined lap time using current WR as a distribution base. This principle ensures proper relations of split and sector times are always observed. It also shows why WR table is important for Airio and why it will refuse to start if the table is not available.

Server Configuration

  • The settings inside Airio.fil.txt are very sensitive because many of them have direct impact on users. You may create very strict racing environment, you can also give players almost complete freedom. Turn on/off individual filters using items as CheckFlooding, CheckTyres, CheckDriving or CheckInactivity. These keys accept only true (the filter is used) or false (the filter is ignored, not used) values.
  • Set up individual used filters by items such as NumRejoins (pertaining to join filter), NumCurses (cursing filter), FloodingTime (text filter), MaxKicks (kick filter), WrongDrivingTimeRace (driving filter), LagCount (lagging filter), InactivityTime (inactivity filter), AllowedSplitTime (speed hack filter) or LockTime (time lock filter).
  • Define specific track rotation scheme using RotateTracks in Airio.srv.txt. An example entry could be BL2|4|XFG+XRG > BL1|4, switching track between BL2 and BL1 each RotateRaces races. Set points for finish places by PointSystem. Define points requirements e.g. by LapsPoints specifying what percentage of completed laps is required to score.

Additional Info

  • Summarize the server rules in Airio.txt.rl.txt file. Write server questions/answers inside Airio.txt.fq.txt. Communicate other info to users by creating/filling Airio.txt.nt.txt file.
  • Create and offer your own language version of user messages by copying Airio.msg.en.txt file, renaming it to Airio.msg.??.txt and translating or adjusting the text values of the defined keys (it may be just partial).
  • Again, look inside all the configuration files (CFG and SRV/FIL), get general understanding of what is possible, see how a thing you do not particularly like might be changed or adjusted. Watch the server run, try racing, see what other features you do not like, return to config files, etc. In several days you may have a nice racing environment corresponding with your ideas and requirements.

Statistics Files

Internally Airio keeps statistics in hierarchical order on three levels: user (with nickname and personal settings), track (with track-related custom data) and car (with data valid for particular track/car combination). This internal hierarchy is reflected also in STA files being saved and storing all statistical data.

The data are written in plain text so knowing the structure as described below makes is possible to create custom (PHP) Web scripts reading the files, picking the required data, sorting and displaying an output on a Web page. Airio itself currently does not contain any such scripts, but there may be some available soon.

Airio.sta.un.txt

This file contains user data on the highest level. It starts with 5 lines of comments describing the file and then follow basic data about all users that have ever connected to one of the managed servers. Individual data items are written on separate lines, users are separated by one empty line which makes it possible to change the structure in the future if there's a need for this. A user entry consists of 10 items in the following order:

  1. username (registered on LFS, it is the main entity in Airio, sort of a database primary key, all lowercase)
  2. raw nickname (custom defined, updated as it changes, stored in raw LFS format)
  3. date/time of last finished lap (Unix timestamp, whole seconds from 1970-01-01 00:00:00)
  4. comparison base (SB, PB, TG, LB or WB)
  5. user language (selected from the available, such as EN, CZ, ...)
  6. settings (currently more than thirty 0s and 1s specifying what is hidden/shown)
  7. playing points (integer, shown by !ptp and also in !pi output)
  8. driving points (integer, shown by !ptd and also in !pi output)
  9. rating events (integer, sum of safety rating changes)
  10. safety rating (integer, percentage * 100 of current safety rating)
  11. raw username (only in tab-separated file, raw LFS format, not converted to lowercase)
  12. unicode nickname (only in tab-separated file, for easier display on Web pages)
  13. experience index (only in FULL and tab-separated file, integer, last known LFSEI * 1000)

Airio.sta.tr.txt

In this file track-specific data for each user are stored. The file again starts by 5 commentary lines, then follows 14 items for each user on separate lines. Users are again separated by an empty line.

  1. username (necessary to bind the item to other user data)
  2. track name (simple short track code saying what track the following data relate to)
  3. soft split 1 (used only in FULL version, custom-defined node on track sector 1 where additional timing data are shown)
  4. soft split 2 (used only in FULL version, as above, only for sector 2)
  5. soft split 3 (used only in FULL version, as above, only for sector 3)
  6. soft split 4 (used only in FULL version, as above, only for sector 4)
  7. not used (always zero)
  8. not used (always zero)
  9. not used (always zero)
  10. not used (always zero)
  11. not used (always zero)
  12. not used (always zero)
  13. not used (always zero)
  14. not used (always zero)

Airio.sta.cr.txt

This file stores user/track/car specific data and is the most important for external display of statistics. Basic structure is the same as with previous files, that is 5 starting commentary lines, then individual items, users again separated by an empty line. One user/track/car combination consists currently of 33 items as described below:

  1. username (necessary to bind the item to other user data)
  2. track name (simple short track code saying what track the following data relate to)
  3. car name (simple short car code saying what car type the following data relate to)
  4. total laps (integer, made in this track/car combination)
  5. PB split 1 time (integer, in centiseconds, that is milliseconds * 10, of 1st split time made during PB lap)
  6. PB split 2 time (as above, only 2nd split time made during PB lap, if the track has 1 split only, this is also PB lap time)
  7. PB split 3 time (as above, only 3rd split time made during PB lap, if the track has 2 splits only, this is also PB lap time)
  8. PB split 4 time (as above, only 4th split time made during PB lap, always also total PB lap time)
  9. date/time of the PB (Unix timestamp)
  10. TB sector 1 time (integer, in centiseconds, that is milliseconds * 10, of best 1st sector time ever made)
  11. TB sector 2 time (as above, only best 2nd sector time ever made)
  12. TB sector 3 time (as above, only best 3rd sector time ever made, if the track contains such)
  13. TB sector 4 time (as above, only best 4th sector time ever made, if the track contains such)
  14. total points (integer, total points scored on this track/car combination, shown by !ptt, deleted by !clrt)
  15. total race podiums (long, in FULL version only, storing 1st places * 1012 + 2nd places * 106 + 3rd places)
  16. total series podiums (long, in FULL version only, as above but for podiums in groups of races)
  17. total best lap time (integer, centiseconds, shown by !btl or !laps commands)
  18. total best race time (integer, centiseconds, shown by !btr or !races commands)
  19. total drifting points (integer, shown by !btd or !drifts commands)
  20. total average lap time (long, in FULL version only, storing # of laps * 109 + total time in centiseconds)
  21. alternate total points (integer, used in FULL if UseAlternatePoints is set on specific server)
  22. championship points (integer, champ points scored on this track/car combination, shown by !ptc, deleted by !clrc)
  23. championship race podiums (long, in FULL version only, storing 1st places * 1012 + 2nd places * 106 + 3rd places)
  24. championship series podiums (long, in FULL version only, as above but for podiums in groups of races)
  25. championship best lap time (integer, centiseconds, shown by !bcl or !lap commands)
  26. championship best race time (integer, centiseconds, shown by !bcr or !race commands)
  27. championship drifting points (integer, shown by !bcd or !drift commands)
  28. championship average lap time (long, in FULL version only, storing # of laps * 109 + total time in centiseconds)
  29. alternate championship points (integer, used in FULL if UseAlternatePoints is set on specific server)
  30. dynamic intake restriction (integer, FULL version only, required value per car type + 1)
  31. dynamic added mass (integer, FULL version only, required value per car type + 1)
  32. target time (integer, FULL only, centiseconds, set/shown by !target command as an optional comparison base)
  33. last update (of this particular record, Unix timestamp)

Airio.sta.ac.txt

This is an additional file used for storing named layouts (autocross) data. Its format is exactly the same as of the Airio.sta.cr.txt file, only track names always include layout names (after underscore).

Displaying Statistics

The files are created so that there's as low redundancy as possible. This means that for the most common scenario of displaying best lap times of people on certain track/car combination you have to use two of the above described files. You will filter/sort the Airio.sta.cr.txt file, getting only the required items. But to get nicknames of players, you need to use also Airio.sta.un.txt, with username as the key. Anyway, I hope this description will help you make some nice scripts for your own use and maybe also available to public. One reminder: The STA files are updated every 10 minutes and also on Airio closing/restart.

Closing Notes

This is the end of Airio Admin's Manual. I hope the information presented here was sufficiently clear for you to be able to create your customized setup and run Airio successfully. I'll just repeat, that if you do not understand some feature, contact me through LFS Forum and I'll try to make the document better. Do the same if you spot some errors, factual or syntactic.

Both in User Manual and in this Admin Manual were hints about FULL version of the Airio tracker. If you'd like to know what that release offers for both users and admins, take a look inside the Full Version Manual.

© EQ Worry, 2009