qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-22 12:31:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Update NEWS with some more stuff, and easier-to-read layout.

Browse source
This commit is contained in:
Jeff Teunissen 2002-09-15 09:24:06 +00:00
parent 75c7119cd8
commit 5b113e865f
1 changed files with 122 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

197
NEWS
View file

@ -1,81 +1,128 @@
NEWS for the QuakeForge project NEWS for the QuakeForge project
------------------------------- -------------------------------
changes from 0.3.0 Changes from 0.3.0
o progs engine re-write o Progs engine enhancements.
o fully modular. mod/server independent allowing for standalone * Fully modular. Mod/Server-independant, allowing for
quakec interpreter and client-side quakec. stand-alone QuakeC interpreter and client-side code.
o no longer dependent on progdefs.h (causes problems with quakec * The engine is no longer dependent on progdefs.h. This makes
compilers that strip def names but those progs can be fixed using QuakeForge have trouble with QuakeC compilers that strip
qfdefs) symbol names -- but those can be repaired using the new
o new opcodes and types for version 0.fff.002 progs (version 6 still "qfdefs" tool.
supported) * New basic types, and instructions for using them, for version
o better dynamic string handling with garbage collected strings 0.fff.002 progs (Quake's Version 6 is still supported).
o Objective-C style object oriented runtime (incomplete but functional) * Better dynamic string handling. Dynamic strings are
o runtime linking of builtin functions whose builtin number is 0 ( = #0 garbage-collected.
in qfcc (should work with any qcc derived compiler)) * Object-oriented runtime system, in the style of Objective-C.
o basic debug symbol support (only for qfcc generated progs) including * Runtime fixups of built-in functions whose builtin number is
source lines. zero. If a built-in function is available to the engine, with
o ".self" prefered over "self" for the self entity the same name given in the source code (i.e.
o ".this" field support for object oriented entities "void (void) coredump = #0;"), the engine will set the value
o qfcc: QuakeForge version of qcc. generally rewritten to the actual number used by the engine.
o use QF utils lib for general ustility functions (hash tables, file * Debugging support (needs compiler support, which qfcc
access (incomplete), pak files) provides), including line-number information. Can display the
o use QF gamecode lib for progs info (opcode tables, enums, types, etc) line of text in the source on which an error occurred, if the
o yacc and lexx (using gnu bison and flex) based parser new Cvar "pr_source_path" is set correctly.
o proper temp def handling drasticly reducing the number of global * Instruction-level code dumps are now formatted in an
defs needed for large progs easier-to-read "assembly-code" format.
o make all functions use the same block of defs for their locals (this
is compatable with all known server variants) further reducing the
number of global defs needed for local varaibles (now down to the
largest function rather than the sum of all functions).
o string operators (+ <= < > >=). requires 0.fff.002 progs
o integer, pointer, array, struct and union types (0.fff.002)
o Objective-C style object oriented programming support (Objective-QC or
Ruamoko:). Use @self (entity ".self"; interally) for touch/think/etc
functions and @this (.id ".this"; internaly ) for builtin OO support
for touch/think/etc. "entity self;" will still work so long as @self
is never seen.
o nested/chained function calls work properly.
o simple expressions (eg a = b + c;) compile to a single opcode rather
than two and avoid using a temporary def.
o C-style for loops
o local var initialition (eg local float foo = 0.1;)
o uninitialized variable detection
o unused variable detection
o vararg functions (ie, can write qc functions using ...: @argc and
@argv to access the parameters passed through ...).
o IMPORTANT: evaluation of "!foo & bar" changed from "!(foo & bar)" to
"(!foo) & bar" which is more correct but incompatable with qfcc. A
warning will be generated for the former unless --traditional is used
on the command line and then a notice will be generated and the old
evaluation used (ie, all is not lost:)
o Uses cpp to pre-process the files
o can generate/link object files (.qfo files)
o library file support (.qfo files in a .pak file)
o strict type checking
o Enhanced console scripting - GIB o QuakeForge Code Compiler, qfcc -- a replacement for qcc.
o New language derived from the quake console. * Uses libQFutil for general utility functions such as hash
o Functions with arguments and return values. tables, file access (incomplete), and pak files.
o Looping (while, for) and branching (if) commands. * Uses libQFgamecode for progs information, such as opcode
o Local and global variables as well as access to cvars. tables, enums, types, etc.)
Supports Python-like slicing of variables. * Uses a lex/yacc (actually, Flex and Bison) scanner/parser
o A basic math interpreter that respects order of operations architecture, like a "real" compiler does.
and provides most arithmetic and logic operators. * Drastically reduces the number of global defs needed for
o Non-preemptive threading and callbacks to GIB functions in a given progs, by reusing temporary globals when possible.
response to game events (limited but functional at the moment) * All functions use the same block of defs for their local
o File reading, writing, and searching. variables (compatible with all known servers), which further
o Integrates with console -- GIB functions can be exported as reduces the number of global defs needed.
console commands to be used at the console or in binds. * Nested/chained function calls work properly.
o See gib.html in doc for more information. * Simple expressions, such as "a = b + c", compile to a single
instruction instead of two, and do not use a temporary
variable.
* Local variables can be initialized to known values, as in
"local float foo = 0.1;".
* Uses the C preprocessor, so header files are now possible and
useful.
* The compiler checks for uninitialized and unused variables in
functions, to help in finding errors.
* The compiler can generate and use object files, for separate
compilation (you don't have to compile all of your source all
the time, only the parts that have changed). Normally, object
files have a .qfo extension.
* The compiler can link libraries, which are implemented as .qfo
files inside pak archives.
* The compiler implements stricter type checking, to assist in
finding and fixing code errors.
* The C language's "for", "do...while", and "switch" control
structures have been adopted to provide a richer set of
structures for programmers to use.
* Additional functionality is given for progs that are to be
used with QuakeForge's more advanced progs engine:
o Enhanced time cheat (speed cheat) protection x IMPORTANT:
o Speed cheat only works for a split second before protection The order of operations is slightly different in "native"
kicks in. mode. The evaluation of "!foo & bar" is no longer
o Players moving at the wrong speed are sped up/slowed down to "!(foo & bar)", but rather "(!foo) & bar". The new order of
the correct speed. operations rules is more correct, but is different from how
o Delay before protection activates means that lag and normal QCC evaluated. If you give the --traditional switch to
network latency won't affect protection. qfcc's command-line, the old behavior is used.
o People who aren't really trying to cheat won't be kicked :) x The compiler now allows you to create your own functions
that can accept a variable number of arguments, using the
special "..." notation. The special constants "@argc" and
"@argv" help with this. @argc contains the number of
arguments, and @argv contains a list of those arguments. The
handling of this is an improvement on C's vararg function
handling, in our opinion, made possible by how the Quake
system works.
x New basic types: integer, pointer, enum, and id.
x You can create new complex types, like arrays, structures,
and unions, and allocate them at runtime.
x String operators. You can add strings together to
concatenate them, and you can compare their contents using
the <=, <, >, >= operators.
x The integer type has the full array of C operations
available to it.
x QFCC and QuakeForge now contain an object-oriented
programming system, in the style of Objective-C and
Smalltalk. It's *very* powerful, and can be used to create
lots of interesting new things with rather little effort. If
you don't wish to use the new system, you can safely ignore
it with no danger to your code. :)
x Special support for using the "self" special variable inside
OO methods as well as the entity of the same name. If you
use OO support for entities and want to assign a method as a
touch/think/etc. function, "self" always refers to the
object that "owns" the method being executed. The special
variable "@self" was created to refer to the self entity.
"@this" refers to the object.
o Enhanced console scripting - GIB (GIB Isn't Bash)
* New language derived from the quake console.
* Functions with arguments and return values.
* Looping (while, for) and branching (if) commands.
* Local and global variables as well as access to cvars.
Supports Python-like slicing of variables.
* A basic math interpreter that respects order of operations
and provides most arithmetic and logic operators.
* Non-preemptive threading and callbacks to GIB functions in
response to game events (limited but functional at the moment)
* File reading, writing, and searching.
* Integrates with console -- GIB functions can be exported as
console commands to be used at the console or in binds.
* See gib.html in doc for more information.
o Enhanced time cheat ("speed cheat") protection
* Time cheats only work for a split-second before protection
kicks in.
* Players moving with wrong timings are sped up/slowed down to
the correct speed.
* Delay before protection activates means that lag and normal
network latency won't affect protection.
* People who aren't really trying to cheat won't be kicked :)
o Rendering enhancements
* TBD