ASSS Wiki - User contributions [en]

Main Page

2005-06-07T07:17:54Z

Grelminar: update link to windows version

<div style="border: 1px solid #c6c9ff; background-color: #f0f0ff; text-align: center; font-variant: small-caps;">
Quicklinks:
[[:Category:ASSS|ASSS Documents]] | [[:Category:FAQ|Frequently Asked Questions]] | [[:Category:Guides|Guides]] | [[:Category:Definitions|Glossary]] | [[:Category:Utilities|Utilities]] | [[Special:Categories|More...]]
</div>

<table cellspacing=10><tr valign="top"><td>
<h3>What is ASSS?</h3>
[http://www.sscx.net/asss/ ASSS] (A Small Subspace Server) was created by [[User:grelminar|grelminar]]. Its an open source server designed to allow [[Continuum]] users to connect with. Its a replacement, not a clone, of [[Subgame]], which was created by [[VIE]] and later upgraded by [[PriitK|Priit Kasesalu]], a freelance [[Subspace]] programmer who also wrote Continuum with the assistance of [[Mr Ekted]].

ASSS allows many advanced features never before offered by Subgame nor user-made [[Bots]]. Within, you'll find documentions about how to use some of these advanced features, and documentation about how to create your own extensions to the server software.

To start finding answers try the quicklinks (above) or check out the [[Special:Categories|Categories]]. If you're having problems with your server, try reading the [[Server Troubleshooting]] guide. If you would like to contribute see [[ASSS_Wiki:Community Portal|Community Portal]]. For further assistance or questions, please visit the [http://forums.minegoboom.com Server Help Forums] where other users will be able to respond to your questions.

<h3>External Links</h3>

*[http://www.sscx.net/asss/ ASSS]
*[http://www.shanky.com/server/ Server Help]
*[http://forums.minegoboom.com/ Server Help Forums]

</td><td style="width: 30%; border: 1px solid #c6c9ff; padding: 5px">
<h3>Current Events</h3>

ASSS version 1.4.0 has been released as of May 14, 2005. From the site: ''There isn't really any new big features here, but it's been a while, and there was some significant reorganization of the source code directory structure and build process, so I figured it deserved a jump in version numbers.'' See the site for a list of the changes.

'''Download'''
*[http://www.sscx.net/asss/asss-1.4.0.tar.gz Full]
*[http://www.sscx.net/asss/asss-1.4.0-srconly.tar.gz Source Only]
*[http://www.sscx.net/asss/asss-1.4.0p1.zip Windows Full]
*[http://www.sscx.net/asss/changelog.txt Change Log]

[[Current events|More Events...]]
</tr></table>

Writing Modules In Python

2005-02-09T07:42:40Z

Grelminar: few cleanups for persistent example

== Basic python module ==
I have tried to comment what is going on in the source. This module demonstrates callbacks, commands and using interfaces.
<pre>
# demo asss python module
# dec 28 2004 smong

# nearly always use this
from asss import *

# get some interfaces
# see chat.h for where I_CHAT comes from, see other .h files for more (fx:
# game.h)
chat = get_interface(I_CHAT)

# a callback
# this function is called when a player enters/leaves, see core.h for PA_???
# constants
def paction(p, action, arena):
# start indenting
if action == PA_ENTERARENA:
# see chat.h for the names of more functions like SendMessage
chat.SendMessage(p, "hello " + p.name)

# tell asss to call 'paction' when CB_PLAYERACTION is signalled
# see .h files for CB_??? names
cb1 = reg_callback(CB_PLAYERACTION, paction)

# a command
# see cmdman.h for what each parameter does
def c_moo(cmd, params, p, targ):
# help text (?help moo)
"""\
Module: <py> demo
Targets: none
a sample command.
"""
chat.SendMessage(p, "moo cows")

# tell asss to call 'c_moo' when a player types ?moo
# note: add cmd_moo to conf/groupdef.dir/default so players have permission to
# use this command.
cmd1 = add_command("moo", c_moo)

# setting chat (or other interfaces), cb* or cmd* to None is equivalent to
# unregistering that item.
</pre>
Save this in bin/demo.py. Then ingame make sure pymod is loaded by using ?lsmod and ?insmod. Then add this module with the following command: ?insmod <py> demo. Re-entering the arena and typing ?moo should do some stuff.

== Code snippets ==
The bread and butter of most custom modules.
=== Callbacks ===
<pre>
from asss import *

chat = get_interface(I_CHAT)

def goal(arena, p, bid, x, y):
chat.SendArenaMessage(arena, "goal.")

cb1 = reg_callback(CB_GOAL, goal)
</pre>

=== Commands ===
Useful for controlling events, fx: ?elim start. In this case the command is ?t1.
<pre>
from asss import *

chat = get_interface(I_CHAT)

def c_mycmd(cmd, params, p, targ):
"""\
some help text
"""
chat.SendMessage(p, "moo.")

cmd1 = add_command("t1", c_mycmd)
#where the "t1" is located would be the name of the command, ex: ?t1
</pre>

You can parse integers from the params using the following code:
<pre>
try:
val = int(params)
except ValueError:
# here the conversion of params from a string to an int failed.
# change the next line to 'pass' to silently ignore the conversion error,
# 'return' to exit the function, or 'val = 0' to set a default value to val.
chat.SendMessage(p, "Integer parameter required.")
</pre>

=== Per-player/arena data ===
Use this to store game state, player score, etc.
<pre>
def shipchange(p, newship, newfreq):
# prefix mymod_ an abbreviation of your module name to the variable
# so that it doesn't clash with other modules. per arena data works
# in exactly the same way.
p.mymod_lastship = p.ship

cb1 = reg_callback(CB_SHIPCHANGE, shipchange)
</pre>

=== Persistent per-player data ===
ASSS has built in mechanisms for saving data per player and per arena data across sessions (users logging off or server restarting).

You need to provide three functions that will be called by ASSS to save, restore and clear the data. The example below is a complete module.
<pre>
# each player can save a note that only they can see
# initial version feb 7 2005 by smong for asss wiki

from asss import *

chat = get_interface(I_CHAT)

# show and store a note
def c_note(cmd, params, p, targ):
if params:
p.note = params
if p.note:
chat.SendMessage(p, "note: %s" % p.note)
else:
chat.SendMessage(p, "no note set")

cmd1 = add_command("note", c_note)

# return the data to save for player p
# returning None means "don't store a record in the database,
# and delete any record that's there already".
def getpd(p):
return p.note

# restore the data for player p
def setpd(p, d):
p.note = d

# reset/clear the data for player p
def clearpd(p):
p.note = None

mypd = reg_player_persistent(
7890, INTERVAL_FOREVER, PERSIST_GLOBAL,
getpd, setpd, clearpd)
</pre>
Ideally you should load the module when the server starts. Alternatively if you load it dynamically you can even kick everyone (not desirable) or alter the code to catch AttributeError when it attempts to read from the per player data ''.note''.

Taking a look at ''reg_player_persistent'' the number ''7890'' is arbitrary, but must be unique for every module using persistent data. Low numbers are reserved for the core modules. ''INTERVAL_FOREVER'' is how long this data will be kept for. Interestingly the INTERVAL_* constants are defined in statcodes.h, not persist.h. ''PERSIST_GLOBAL'' is defined in persist.h. Here are the respective code extracts (as of Feb 7 2005).
<pre>
/* these are the possible intervals */
enum interval_t
{
/* pyconst: enum, "INTERVAL_*" */

/* these are shared between arenas with the same arenagrp */
INTERVAL_FOREVER = 0,
INTERVAL_RESET,
INTERVAL_MAPROTATION,
/* these are not shared between arenas */
INTERVAL_GAME = 5,
INTERVAL_FOREVER_NONSHARED
};
</pre>
<pre>
typedef enum persist_scope_t
{
/* pyconst: enum, "PERSIST_*" */

PERSIST_ALLARENAS,
/* using this for scope means per-player data in every arena */
/* using this for scope means per-arena data will be stored
* per-arena */

PERSIST_GLOBAL
/* using this for scope means per-player data shared among all arenas */
/* using this for scope means per-arena data will be shared among
* all arenas (so it will effectively be global data). */
} persist_scope_t;
</pre>
Note: ASSS must be compiled with the berkeleydb option for persistent data to be available.

=== Attach/Detach ===
Attaching and detaching is similar to load/unload in a C module except it is arena specific. So you can use it to initialise per-arena data.
<pre>
def mm_attach(arena):
# do stuff with arena
def mm_detach(arena):
# undo stuff
</pre>

=== Looping over all players ===
This example counts the number of players in an arena.
<pre>
def count_players(arena):
# a list must be used as all other variables are immutable to
# nested functions.
players = [0]
def cb_count(p):
if p.arena == arena:
players[0] = players[0] + 1
for_each_player(cb_count)
return players[0]
</pre>

=== Timers ===
Good for checking if a game is over yet. '''A reference to the timer is returned and must be retained''' (you can use per-arena data to store it). Losing the reference will cancel the timer.

''initial'' is the time in 1/100th's of a second before the nested function timer() will be called, you can cancel the timer before it is called. ''interval'' is the time gap, again in 1/100th's of a second between all future calls of timer(). So make_hello_timer(100, 200, arena) will make it send the arena message "hello" every 2 seconds starting from 1 second after make_hello_timer() was called.

The parameter ''arena'' is needed in this case because SendArenaMessage() requires an arena parameter.
<pre>
def make_hello_timer(initial, interval, arena):
def timer():
# announce
chat.SendArenaMessage(arena, "hello")
# non-repeating timer. return 1 for it to be called after the next interval
return 0
return set_timer(timer, initial, interval)

def somefunc(arena):
# create a hello timer that will execute after 1 second, and then every
# 2 seconds until cancelled. timers can cancel themselves, see above.
myref = make_hello_timer(100, 200, arena)

# cancel the timer by losing the reference to it
myref = None
</pre>

=== Regions ===
This is untested but it should go something like this:
<pre>
mapdata = get_interface(I_MAPDATA)

# regionname is a string, x and y are map tile coords.
def region_contains(arena, regionname, x, y):
success = 0

rgn = mapdata.FindRegionByName(arena, regionname)

if rgn != None and mapdata.Contains(rgn, x, y):
success = 1

return success
</pre>
It is a good idea to cache ''rgn'' within [[#Per-player.2Farena_data|per-arena data]] so you don't add unecessary load to the server looking it up everytime.

== Trouble shooting ==
Look at the asss console for execution errors (at the time of writing not all errors are relayed to logged in staff), and if that doesn't help, add some chat.SendArenaMessage(ALLARENAS, "i'm at line ...") type messages to locate the buggy piece of code.

[[Category: Module]]
[[Category: Tutorial]]

User talk:BaK

2005-02-02T08:48:26Z

Grelminar:

Check out [[SheepMessage]] for a template for the Settings. I think that looks better? --[[i88gerbils]]

[[User:Smong|Smong]]: Bak: I don't know if you have forgotten, but the game is still called Subspace. Why do you only mention Continuum in all your pages?

[[User:Smong|Smong]]: When you only mention Continuum, you are making it seem like what you are talking about is in Continuum only. This is acceptable for things like *watchdamage and *warpto. Features like cloak, although old, are fundamental to the game and have been around since Subspace.

Dude, leave my name alone. I'll make changes if I want them. --grel

Talk:Ship Settings

2005-01-19T07:34:28Z

Grelminar: settings talk

Isn't this kinda a pointless page? I mean, all this information is in [[Complete Settings]] and is dispersed in greater detail in each section's page. --[[User:Cyan~Fire|Cyan~Fire]]

[[User:Pests|Pests]]: This and Complete Settings are two different things. Theres a section in the template.sss named "All" and Complete Settings has EVERY section, including this "All" section.

That's pretty confusing, especially considering the section name "All" never appears in an actual config file. It's just a shorthand that means there are eight sections these settings can go in, one for each ship type. Futhermore, it would be good to differentiate between settings that apply to subgame, settings that apply to asss, and settings that apply to both, before just mindlessly dumping the contents of template.sss on here. --[[Grelminar]]

Talk:Creating New Subarenas

2005-01-16T23:30:09Z

Grelminar: question about includes

Who wrote this bit:
"If you use ?makearena and arenas/(default)/arena.conf #include's local files such as flags.conf then the server will generate errors as it will not be able to find these in the new arena's directory."
?

Because that's not supposed to happen: if you put #include flags.conf in arenas/foo/arena.conf, and arenas/foo/flags.conf doesn't exist, it's supposed to use arenas/(default)/flags.conf. Is that not working?

Module General Faq

2005-01-16T23:23:19Z

Grelminar: make text clearer

== I want to put in more modules, how do I do this? ==

'''For C modules:'''

To add modules to a zone, to be loaded on startup, edit your <tt>conf/modules.conf</tt> file, and add a new line containing <tt>filename:modulename</tt>. The <tt>filename</tt> part must be the name of an <tt>.so</tt> or <tt>.dll</tt> file in the zone's <tt>bin</tt> directory.

Or you can dynamically load the module in-game by using <tt>?insmod filename:modulename</tt>. You can use ?help insmod for more info.

'''For Python modules:'''

Mostly the same thing, except you must use <tt>?insmod <py> modulename</tt> or <tt><py> modulename</tt> in modules.conf. The <tt>modulename</tt> should be the name of a <tt>.py</tt> file in your zone's <tt>bin</tt> directory.

== I added a custom module, why aren't the commands working? ==
You can add new commands to the group files found in conf/groupdef.dir. Prefix cmd_ to the command to allow users to send the command publicly and privcmd_ for team and private targets.

[[Category: Module]]
[[Category: FAQ]]

Installing New Modules

2005-01-16T23:16:06Z

Grelminar: fixups to previous edit

Firstly I want to say this is how I do it (Smong). Others may do it differently and can edit this page.

When you want to add more functionality to your server you can install new custom modules. Differences in server version often mean something will break in a module, so I like to distribute with source code.

== C modules ==

=== Using the ASSS Makefile ===
The Makefile distributed with ASSS is designed to allow adding new code to it easily. This is probably the easiest way to get a new module compiling, because all the correct compiler flags are supplied for you.

Create a directory for your module as a subdirectory of <tt>src</tt>, the directory containing all the ASSS code.
<pre>
$ cd asss-1.3.5/src
$ mkdir mymod
</pre>

Create a <tt>mymod.mk</tt> file within that directory that looks like this:
<pre>
mymod/mymod.$(SO): mymod/mymod.o
</pre>

All <tt>*.mk</tt> files (let's call them "Makefile fragments") in any subdirectories will be included by the big Makefile automatically. Two fragments come in the contrib directory in the ASSS package, which you might want to look at as examples.

Note that we use a Makefile variable, <tt>$(SO)</tt>, instead of typing <tt>.so</tt> directly. That's so that the same Makefile works on windows, where modules have to be named <tt>mymod.dll</tt> instead of <tt>mymod.so</tt>. Also note that all the filenames have to be prefixed with the directory they're in. That's because make considers all files relative to the directory it runs in.

Now compile your module and copy it into your bin directory:
<pre>
$ make mymod/mymod.so
... compiler output ...
$ install mymod/mymod.so ../bin
</pre>

Note that you have to specify the target name manually; it won't get built or copy by default if you just type <tt>make</tt>. If you do want your custom module to get built and copied automatically, along with the rest of ASSS, when you type just <tt>make</tt>, add this line at the top of the Makefile fragment:
<pre>
ALL_STUFF += mymod/mymod.$(SO)
</pre>

Also note that you can list more than one <tt>.o</tt> file on the line. All will be compiled into the same shared library.

The module specifier for this new module will be <tt>mymod:mymod</tt>, for use in modules.conf or with ?insmod.

=== Using a custom Makefile ===
Sometimes you might want to create your own Makefile, if you need to use custom compilation options, or a different source file layout. Here is a very basic one (they can get very long).
<pre>
# simple makefile
# jan 11 smong

OUTFILE = somefile.so
MODULES = autoturret.o

CC = gcc -std=gnu99 -pipe
CFLAGS = -s -O2 -Wall

all: ${OUTFILE}

${OUTFILE}: ${MODULES}
${CC} -fPIC -shared -o ${OUTFILE} ${MODULES}

install: ${OUTFILE}
install ${OUTFILE} ../bin/${OUTFILE}

clean:
rm -f ${OUTFILE} ${MODULES}
</pre>
You can change the name of the resulting file with ''OUTFILE'' and add more modules on the ''MODULES'' line. Note: the indentation must be a tab and not a bunch of spaces.

To use a makefile one would type something like this:
<pre>
$ make -f some.mk
$ make -f some.mk install
</pre>
The ''-f'' switch tells make to use ''some.mk'' instead of the default which is 'Makefile'. Also two commands are used so you can spot any errors during compilation.

=== By hand ===
You may need to execute the commands to compile from source, and then move the resulting .so file to the bin directory using install.

== Python modules ==
No compiling is necessary. Move the .py file to the bin directory. There may be 'softcoded' settings within the .py file, so examine any comments near the top of the file for instructions.

== Configuring ==
It is a good idea to examine any documents that came with the module. There may be comments at the top of the source code and if you are unsure you can do a search on the file for 'cfg->Get', which will return all customisable settings this module reads.
<pre>
$ grep 'cfg->Get' src/module.c
$ grep 'cfg.Get' bin/module.py
</pre>
I suggest putting module settings in their own .conf file and include this from your arena.conf.

There may also be commands that you must set the permissions for. You can add new commands to the group files found in conf/groupdef.dir. Prefix cmd_ to the command to allow users to send the command publicly and privcmd_ for team and private targets.

Finally you must load the module. Either add an entry to conf/modules.conf or use ?insmod. Some modules are arena specific, in which case you must also add it to your arena.conf Modules:AttahModules setting or use ?attmod.

If you have any questions left chances are they have already been answered at the [[Module General Faq|Module FAQ]].

[[Category: Module]]
[[Category: Tutorial]]

Installing New Modules

2005-01-16T23:14:24Z

Grelminar: added instructions for compiling using the asss makefile

Firstly I want to say this is how I do it (Smong). Others may do it differently and can edit this page.

When you want to add more functionality to your server you can install new custom modules. Differences in server version often mean something will break in a module, so I like to distribute with source code.

== C modules ==

=== Using the ASSS Makefile ===
The Makefile distributed with ASSS is designed to allow adding new code to it easily. This is probably the easiest way to get a new module compiling.

Create a directory for your module as a subdirectory of <tt>src</tt>, the directory containing all the ASSS code.
<pre>
$ cd asss-1.3.5/src
$ mkdir mymod
</pre>

Create a <tt>mymod.mk</tt> file within that directory that looks like this:
<pre>
mymod/mymod.$(SO): mymod/mymod.o
</pre>

All <tt>*.mk</tt> files (let's call them "Makefile fragments") in any subdirectories will be included by the big Makefile automatically. Two fragments come in the contrib directory in the ASSS package, which you might want to look at as examples.

Note that we use a Makefile variable, <tt>$(SO)</tt>, instead of typing <tt>.so</tt> directly. That's so that the same Makefile works on windows, where modules have to be named <tt>mymod.dll</tt> instead of <tt>mymod.so</tt>. Also note that all the filenames have to be prefixed with the directory they're in. That's because make considers all files relative to the directory it runs in.

Now compile your module and copy it into your bin directory:
<pre>
$ make mymod/mymod.so
... compiler output ...
$ install mymod/mymod.so ../bin
</pre>

Note that you have to specify the target name manually; it won't get built or copy by default if you just type <tt>make</tt>. If you do want your custom module to get built and copied automatically, along with the rest of ASSS, when you type just <tt>make</tt>, add this line at the top of the Makefile fragment:
<pre>
ALL_STUFF += mymod/mymod.$(SO)
</pre>

Also note that you can list more than one <tt>.o</tt> file on the line. All will be compiled into the same shared library.

The module specifier for this new module will be <tt>mymod:mymod</tt>, for use in modules.conf or with ?insmod.

=== Using a custom Makefile ===
Sometimes you might want to create your own Makefile, if you need to use custom compilation options, or a different source file layout. Here is a very basic one (they can get very long).
<pre>
# simple makefile
# jan 11 smong

OUTFILE = somefile.so
MODULES = autoturret.o

CC = gcc -std=gnu99 -pipe
CFLAGS = -s -O2 -Wall

all: ${OUTFILE}

${OUTFILE}: ${MODULES}
${CC} -fPIC -shared -o ${OUTFILE} ${MODULES}

install: ${OUTFILE}
install ${OUTFILE} ../bin/${OUTFILE}

clean:
rm -f ${OUTFILE} ${MODULES}
</pre>
You can change the name of the resulting file with ''OUTFILE'' and add more modules on the ''MODULES'' line. Note: the indentation must be a tab and not a bunch of spaces.

To use a makefile one would type something like this:
<pre>
$ make -f some.mk
$ make -f some.mk install
</pre>
The ''-f'' switch tells make to use ''some.mk'' instead of the default which is 'Makefile'. Also two commands are used so you can spot any errors during compilation.

=== By hand ===
You may need to execute the commands to compile from source, and then move the resulting .so file to the bin directory using install.

== Python modules ==
No compiling is necessary. Move the .py file to the bin directory. There may be 'softcoded' settings within the .py file, so examine any comments near the top of the file for instructions.

== Configuring ==
It is a good idea to examine any documents that came with the module. There may be comments at the top of the source code and if you are unsure you can do a search on the file for 'cfg->Get', which will return all customisable settings this module reads.
<pre>
$ grep 'cfg->Get' src/module.c
$ grep 'cfg.Get' bin/module.py
</pre>
I suggest putting module settings in their own .conf file and include this from your arena.conf.

There may also be commands that you must set the permissions for. You can add new commands to the group files found in conf/groupdef.dir. Prefix cmd_ to the command to allow users to send the command publicly and privcmd_ for team and private targets.

Finally you must load the module. Either add an entry to conf/modules.conf or use ?insmod. Some modules are arena specific, in which case you must also add it to your arena.conf Modules:AttahModules setting or use ?attmod.

If you have any questions left chances are they have already been answered at the [[Module General Faq|Module FAQ]].

[[Category: Module]]
[[Category: Tutorial]]

File Commands

2005-01-16T22:54:45Z

Grelminar: stuff about ?renfile and replacing

These are file commands for use on [[ASSS]].
== Uploading and downloading files within the game ==
=== ?getfile <path> ===
This will retrieve a file from the server and download it into your client directory. Useful paths to know are maps and arenas where maps and arenas are located respectively.
<pre>
?getfile arenas/(default)/arena.conf
File received: arena.conf
</pre>

=== ?putfile <local path>[:<destination path>] ===
Don't be put off by the complexity of this command. It can be used like a normal *putfile:
<pre>
?putfile news.txt
Sending file: news.txt
File received: ./news.txt
</pre>
You can supply an optional ''destination path'' by using a colon:
<pre>
?putfile local.lvl:maps/local.lvl
Sending file: local.lvl
File received: ./maps/local.lvl
</pre>
The path is relative to the base directory where asss has been installed. You can also change the filename using the colon method.
<pre>
?putfile arena.conf.bak:arenas/(public)/arena.conf
Sending file: arena.conf.bak
File received: ./arenas/(public)/arena.conf
</pre>

=== ?putzip <somefile.zip>[:<destination path>] ===
This is similar to ?putfile. The optional part after colon is used to specify a target directory rather than a file. The zip file will be uncompressed into this directory or the current working directory (see ?pwd). Any directory tree structure in the zip file is ignored and files from the .zip will overwrite any duplicate files. Note: This command is not available when running ASSS on Windows.

=== ?putmap <somemap.lvl> ===
This will upload ''somemap.lvl'' to maps/uploads/arenaname.lvl where arenaname is the arena you are currently in. It appends a setting to arena.conf to use this map. You will need to reload the arena for the changes to take effect, you can use the ?recyclearena command to do this.

=== ?sendfile <somefile.ext> ===
If you private message this command to another player, it will transfer ''somefile.ext'' to them. Both players must be in spectator mode first. ''somefile.ext'' must be in the same directory as your game client, for example C:\Program Files\Continuum.

== Helper commands ==
There are two helper commands that can be used with these three, ?cd and ?pwd.

=== ?cd <path> ===
With this command you can change the current directory. By default it will start off as ., the base directory for the asss install.
<pre>
?cd arenas/(public)
Changed working directory.
</pre>
You shouldn't use .. or end the path with /. This command is different from the cd command that you would find in a shell in that the parameter is always taken to be relative to the asss base directory.

=== ?pwd ===
The print working directory command shows where you are currently located.
<pre>
?pwd
Current working directory: .
</pre>

=== ?renfile <filename>:<new filename> ===
This command will rename a file. The path is relative to the current directory. If the destiation file already exists, it will be replaced (due to a bug, replacing won't work on Windows in versions <= 1.3.5). This command can be used to move files between directories.

=== ?delfile <filename> ===
This will delete a file, so use caution with this. Again the path is relative to the current working directory.

[[Category: ASSS]]
[[Category: Tutorial]]

File Commands

2005-01-16T22:48:26Z

Grelminar: fixed confusing statement about ?putzip and windows

These are file commands for use on [[ASSS]].
== Uploading and downloading files within the game ==
=== ?getfile <path> ===
This will retrieve a file from the server and download it into your client directory. Useful paths to know are maps and arenas where maps and arenas are located respectively.
<pre>
?getfile arenas/(default)/arena.conf
File received: arena.conf
</pre>

=== ?putfile <local path>[:<destination path>] ===
Don't be put off by the complexity of this command. It can be used like a normal *putfile:
<pre>
?putfile news.txt
Sending file: news.txt
File received: ./news.txt
</pre>
You can supply an optional ''destination path'' by using a colon:
<pre>
?putfile local.lvl:maps/local.lvl
Sending file: local.lvl
File received: ./maps/local.lvl
</pre>
The path is relative to the base directory where asss has been installed. You can also change the filename using the colon method.
<pre>
?putfile arena.conf.bak:arenas/(public)/arena.conf
Sending file: arena.conf.bak
File received: ./arenas/(public)/arena.conf
</pre>

=== ?putzip <somefile.zip>[:<destination path>] ===
This is similar to ?putfile. The optional part after colon is used to specify a target directory rather than a file. The zip file will be uncompressed into this directory or the current working directory (see ?pwd). Any directory tree structure in the zip file is ignored and files from the .zip will overwrite any duplicate files. Note: This command is not available when running ASSS on Windows.

=== ?putmap <somemap.lvl> ===
This will upload ''somemap.lvl'' to maps/uploads/arenaname.lvl where arenaname is the arena you are currently in. It appends a setting to arena.conf to use this map. You will need to reload the arena for the changes to take effect, you can use the ?recyclearena command to do this.

=== ?sendfile <somefile.ext> ===
If you private message this command to another player, it will transfer ''somefile.ext'' to them. Both players must be in spectator mode first. ''somefile.ext'' must be in the same directory as your game client, for example C:\Program Files\Continuum.

== Helper commands ==
There are two helper commands that can be used with these three, ?cd and ?pwd.

=== ?cd <path> ===
With this command you can change the current directory. By default it will start off as ., the base directory for the asss install.
<pre>
?cd arenas/(public)
Changed working directory.
</pre>
You shouldn't use .. or end the path with /. This command is different from the cd command that you would find in a shell in that the parameter is always taken to be relative to the asss base directory.

=== ?pwd ===
The print working directory command shows where you are currently located.
<pre>
?pwd
Current working directory: .
</pre>

=== ?renfile <filename>:<new filename> ===
This command will rename a file. The path is relative to the current directory. '''someone confirm if this overwrites ''new filename'' if it already exists'''

=== ?delfile <filename> ===
This will delete a file, so use caution with this. Again the path is relative to the current working directory.

[[Category: ASSS]]
[[Category: Tutorial]]

CCC

2005-01-13T09:29:00Z

Grelminar: more features

CCC is a chat client using the [[ChatNet Protocol|TCP chat protocol]]. It's written by Grelminar, and it's written in Python. You can get it in the ASSS distribution, or from http://sscx.net/asss/ccc.

Features:

* runs in a console windows, so it's easy to use over ssh
* auto-reconnecting after disconnection
* complete logging of everything to a file
* double-colon support
* separate windows for different chat channels, mod chat, and private messages
* multiple profile support
* auto-enter commands

[[Category: ChatNet Clients]]

CCC

2005-01-13T06:51:22Z

Grelminar: add info about ccc features