Topics

I don't think it's currently possible to go directly to a specific line number in the Script Editor.   If not then it would it be possible to add such function, accessable from menu and/or keyboard short-cut, that would provide for this?  Thanks.

I came across this by accident, book-marked it for myself, and thought someone may be interested in it. 

http://www.csounds.com/

I know this has been asked before but couldn't find it on the tracker.    Since DOS has faded into infamy does the current 15 char limit serve any purpose? 

It's starting to interfere with the naming conventions I am trying to use.  I know that 15 char sound like a lot but after you add in a rev number, the distribution type, and an indication if it is a game, module, template, or plugin there isn't much room left for a name.  And yes, the distribution name doesn't necessarily have to match the game name but it sure would make things a lot easier.

Anyway I hope this makes it on a wish list somewhere.   

[MiniGame Template]

Currently the "New Room" function will populate the new room's script file with the contents of _blank.crm.  This is really handy but there are a couple of small things that would make it much more useful.

• Template - include the _blank.crm file in a game templatez made from the "Game Make Template" function.
  
  
• AGS Directory - if the file is not found in the game directory could AGS then look for it in the directory from which AGSEDIT.EXE is running?
  
  
• New Module - could we also have the same ability to populate a new module with the contents of a _blank.scm file when using the "New Module" command?   Again the file could be either in the game or agsedit directories and included in any game templates made as above.
  
  
• Template Creation - could the "Make Template" command also collect other folders from the game directory, at least one called Document but preferably all or a specified list?
  
  [edit]and one more...
  
  
• Is there a maximimum number of characters that can be in the template.txt file?   I have made a template that contains this template.txt file.   When I create a new game using this template the template.txt file is displayed on a popup dialog but when the dialog is closed AGS crashes.  The game is created and if I try to open it again everything seems to be find.  I know that the file is too large to fit in the dialog but couldn't it just display the first x number of characters instead of crashing? Oh and here is the game template:
  
  MiniGame Template
  
  
  I know these are not of a high priority but thanks for listening anyway.
  
  Cheers
  RickJ
  

Hey everyone,

I am in the process  of  upgrading DenoQuest to V2.72 compatibility.  The script code in the GUI example rooms needs a lot of work.   The last time around I just extracted the code from the previous DemoQuest version's Global Script to make them into mini-games and didn't do much else.   I would like to make some improvements but before I put a lot of effort into this I thought I ask some questions irst.

• The current collection examples are listed below.   Is this the right collection of GUI's or should some of these be removed or others added?   There is currently one unused dor in the hall of GUIs.  Also there is a menu door that allows  GUI rooms to be chosen from  a list so there is no hard limit, only a practical size limitation.
  
     o DqAgi       - AGI Text Parse
     o DqAgiPnC - AGI Text Parse + Point & Click Functionality
     o DqLec       - Lucas Arts
     o DqSci0      - SCI
     o DqSciPnC  - SCI + Point & Click Functionality
     o DqGVC       - Verb Coin
  
  
• It seems to me that there should be a good game template for each of the GUI examples.   The last time I checked, the examples for which there were templates, the corresponding templates were out of date and not compatiable with the new version of AGS.   Are there newer, better,  or revised templates for any GUI examples that are (or should be) part of DemoQuest? 
  
  
• Are there any would be Template designers who would like to participate in this process?   Please let me know if so.
  
  Any comments, ideas or suggestions will be greatly appreciated.
  
  Cheers
  RickJ
  
  P.S.   Everyone is always welcome to contribute to DemoQuest; always in need of artists, muscians, etc.   
  

[game.name]

I have a couple of ideas regarding system defined variables.  The first one I would find immediately useful.  The second one is more of a request for discussion than for an immediate feature. 

• game.name - Would it be possible to add a game.name or game.filename variable so that one could find the file name of the game that is running from within the game.  If implemented, the current game's name wouldn't need to be specified by the user.   A String containing the file name without the extension would work just dandy.
  
  
• gs_globals -  The documentation says that these are obsolete and so nobody should use them in a new design.    Presummably they are still in the engine for compatibility reasons and because CJ hasn't gotten around to removing them yet.    Anyway what would everyone think about making gs_globals  "persistent"  so that the data contained in the gs_global array would survive RestoreSaveSlot() and RunAGSGame() operaqtions?  I suppose it could be an option if compatibility was an issue.
  
  Currently it is nearly nearly impossible to set a flag or state that will be preserved after a restore operation is complete.   Even writing the data to a file is a bit tricky because you still need to know when to read the file.   
  
  Currently there is an option to retain the values of global ints through RunAGSGame().  The problem is that global ints are in fairly common usage and a module that required them to be used a certain way would be an intolerable annoyance to many wouold be users of the module.   Since the use of gs_globals  ought to be much less common  such a module requirement should be proportionatly less annoying. 
  
  Anyhow, feel free to flame away!   

I just came across something called Korelib which claims to be "A cross-platform library for plugin-based applications".  Is this something that could be used to allow plugins to be portable?   

[Need an App to run on Linux? Request it here!]

Novel is hosting a survey to see which applications users want ported to Linux.  You can take the survey here:

Need an App to run on Linux? Request it here!

and you can see the preliminary results here:

The Application People Most Want Ported to Linux Is...

The results are starting to come in for the Linux App Request Survey we first posted at the beginning of January. There are some really interesting trends that we can see from the results. ...

Of those top 10 applications, two of them are financial management packages. Looks like there is quite a demand for that. It looks like there is a huge interest in the AUTOCAD arena, as well. Something that is very well worth noting is the demand for multimedia applications....

Guys, if we want to make a big enough impact for change to actually take place, we need to get many more people helping with this study. If you know anyone who uses Windows (which is a lot of people), please send them a link to this survey. Every single vote counts. If we want to actually convince Intuit to make QuickBooks and Quicken for Linux, we have to get their attention. The same goes with all the other applications listed here.

[Queue After Script]

I am in the process of updating the MiniGame module and hope to make an official release soon.   There are a couple of quirks in the script language that require a bit of a  convoluted work around that I would like to eliminate.

Queue After Script
Some script commands don't execute until after the curent script is finished.   SaveGameSlot() is the one I am particularly interested in.   In the Example below the SaveGameSlot() function is never executed because the  RunAGSGame() function immediately after closes the current game and starts the new one before the SaveGameSlot ever has a chance to execute.   I am not certain if there are other built-in functions that have the same or similar behavior. 

Code: ags

	MiniName = String.Format("%s Return",mininame);
	SaveGameSlot(MiniGame_SAVSLOT,MiniName);
	Wait(1);
	RunAGSGame(mininame,0,game.previous_game_data+1); 

I was thinking it would be handy if there were a way of synchronizing these type of functions with other code.    I suppose there are any number of implementations that would be acceptable.  One possibility is  the introduction of a new keyword as shown in this example:

Code: ags

	// Script code executes normally
	MiniName = String.Format("%s Return",mininame);

	// The new keyword quesup instructions to be executed 			// after script completes.
	QueueAfterScript {   
		SaveGameSlot(MiniGame_SAVSLOT,MiniName);
		RunAGSGame(mininame,0,game.previous_game_data+1); 
	}

The other idea that comes to mind is to have another version of Wait() that would accomplish the dsame thing.  Perhaps the latter (i.e. Wait()) would be more intuitive for most people.

RestoreGameSlot()
When returning from a minigame it is desireable to seamlessly return to the previous game in it's previous state.   Currently this isn't possible because RestoreGameSlot() can't be executed until aafter the first room is displayed.  The workaround is to have the game's first room be a dummy black room with a some code to determine if returning from a minigame or starting from the OS.   

Since it's now possible to do a NewRoom command in game_start() I was wondering it could also be made possible to allow RestoreGameSlot() to be run from within game start?   

Alternative Suggestion
If the above two items are deemed to be relevant only to RunAGSGame() the perhaps a better solution would be to integrate the save/restore functionality within RunAGSGame() itself as follows:

Code: ags

RunAGSGame (string filename, int mode, int data, optional int saveslot, optional int restoreslot)

saveslot - if this parameter is specified and greater than -1 then the current game is saved to this saveslot before starting the new game.

restoreslot - if this parameter is specified and greater than -1 then the new game is restored from restoreslot before displaying the first room.

Summary
The above two requests would allow the removal of convoluted logic and awakward requirments from the module before release. 

1.  Ability to execute commands after builti-ins such as SaveGameSlot() complete.

2.  Ability to execute RestoreGameSlot() from within game_start().

3. Alternatively integrate save and restore functionality into RunAGSGame() itself.

I believe these changes, if possible and practical, would be of benefit to all.  Thanks for your consideration.

I am upgrading some code to use the new string stuff but am having a small problem.  It's probaly something obvious or a misconception I have.  Perhaps someone can straighten me out.   

Basicaly I am implementing a dictionary consisting of "name" and "value" pairs. 
The function get_buf() looks up the name and returns the associated value.  The logic and code worked fine before trying to upgrade.  Now however, the same code is unable to return the value.   

With old style strings it was possible to return string values by writing to a puunctions parameters.  So do the new style strings not work this way or am I missing something else.   Thanks in advance for any enlightment anyone can provide.


This example is illustrative of the above description.

String  DataName[10];
String  DataValue[10];

function get_buf(String name, String value) {
 
   // The dictionary is filled out by reading a file.
   // in another function.  For the test we will just set it .
   DataValue[0]="555";  

   // A while loop is used to look up the name and get 
   // the corresponding value.   
   value = DataValue[0];

   // At this point "value" contains the cotrrect data
   return true;
}

iGet(String name) {
   String buf="";
   int status;

   // Call the above lookup function.  
   status = get_buf(name,buf);

   // The parameter buf does not contain any 
   // data after the call.
}

I thought I saw a recent post about playing games on the Nokia 770 internet tablet but haven't been able to find the thread.   Anyway I have one now and  wonder if anyone else here has one or has an interest in trying to port AGS games to it.  It runs Debian Linux on an ARM processor so it should be possible with a little help from CJ and/or EvilTypeGuy.

I invite you to share my victory in court (but unfortunately not the money).

I am about $2000 richer today than I was yesterday.   My wife did some work for a translation company and they refused to pay her the last $1000 bucks.  After spending much time and effort talking on the phone, writing letters, etc I filed suit in small claims court.  I asked for the money the owed to my wife and to be compensated for the expense incurred trying to collect.   The other party never showed up ( I think she wrote a letter to the Judge explaining how important her time is ... hehe)  and the Judge gave us everything we asked for plus about $100 more (probably just to show how important time in court is).   

The neat thing about small claims court in the US is that the person named in the suit has to show up in court.   They can't send an attorney in their place or bring one with them.   Normally you have to file suit where the person who is being sued lives,  however, in the case of a company, the suit can be filed anywhere the company does business.   I our case the owner of the company we sued lives a few hundred miles away from us.  Because the company does business in our city and because the work in question was performed in our city that is where we filed.   

Now if some monster company does something to really screw you, you can take them to samll claims court and they will have to come there.   For the small price of about $50 bucks you can have the satisfaction of having a uniformed law enforcement person had deliver your invitation to court to the MAN and have a chance to ask the MAN face to face why he did what he did.   Just make sure the facts and the law are on your side.   

Good luck to all.  Btw, I am 3-0 in small claims court, not a bad track record eh?

[Sony, Rootkits and Digital Rights Management Gone Too Far]

Be careful what music you CD's you play on your computer or this can happen to you!!!

Sony, Rootkits and Digital Rights Management Gone Too Far

Update:
Here is a snippet from a Reuters article that indentifies the CD in question.

... The matter drew increased attention in technology circles October 31, when software developer/computer security expert Mark Russinovich began blogging the details of problems he experienced after using his computer to play the copy-protected CD of "Get Right With the Man" by Van Zant, a Southern rock act signed to Columbia Records.

I have  a roomXX.crm file with a main image and several background frames.  I need to adjust the palette for these images but I don't have the original graphic file.  As far as I can tell the "copy to clipboard" function only grabs the main image.  How can one get copies of the other images?   

And yes, I suppose I could write a script that selects each background frame and creates a screen shot of each but what way ro un a railroad.    If this is the best answer then perhaps this should be a request to implement a proper "room graphic export" function?   

[Unzip to folder: "DQ31SOD-V100"]

The upgrade of DemoQuest to the new script language is nearly complete.   Coding is complete save for some cleanup work and fixes for whatever bugs may turn up.  All reported bugs should be fixed.  You can download the latest Beta version from here:

DQ3SOD-S100-B02.ZIP  (3Mb)  Unzip to folder: "DQ31SOD-V100"

The Arcade and Gui rooms have been converted to mini-games.  They can now be played from within DemoQuest just as before and the may also may be played directly from the OS.  Beta releases of all the mini games are available below.  They come with source code, graphics, etc.

DQCYCLE-A100-B01.ZIP        Unzip to folder: "DQCYCLE"
DQGAGI-A100-B01.ZIP         Unzip to folder: "DQGAGI"
DQGAGIPnC-A100-B01.ZIP      Unzip to folder: "DQGAGIPnC"
DQGSCI0-A100-B01.ZIP        Unzip to folder: "DQGSCI0"
DQGSCIPnC-A100-B01.ZIP      Unzip to folder: "DQGSCIPnC"
DQGVC-A100-B01.ZIP          Unzip to folder: "DQGVC"
DQSLOT-A100-B01.ZIP         Unzip to folder: "DQSLOT"

Here is the puch list I am working from.  It began from a review by Strazer some time ago.   There are several issues that may need more discussion or they may have been adequately addressed already.   So perhaps you could take a look at these and keep them in mind as you review the DQ source code. 

http://www.gaia-spa.com/project/ags/doc/PunchList.txt

Additional project documentation can be found here.   Anyway have a look and let me know if you find any bugs or have any other comments. 

Cheers
RickJ

P.S. Also if anyone has any idea whod did what on the DemoQuest II pleast let me know because I wish to give credit to their hard work. 

Cheers again

I created a custom inventory window but I noticed that speech is displayed behind the GUI; fair enough.   However if the "Display Text As Speech" option in the "General Settings" tab is checked then when one examines items in the inventory gui the resulting text descriptions are displayed behind the GUI.   

Has it always been this way or is this a bug or something introduced by V2.7, or have I done something wrong?

If it's supposed to work this way then I wonder how useful the "Display Text as Speech" option is;  in fact it would seem to me to cause more harm than good.   

[Abstract]

Abstract
AGS  allows one game to activate another game via the RunAGSGame() script function.  This  is useful in implementing arcade sequences and other game-within-a-game type things. These can be called Mini Games  and  designed  to be run stand-alone or from within another game. 

This module provides an easy method of calling and returning from mini games and an easy method of passing data back and forth. Examples illustrating the use of these  functions  are presented in subsequent sections of this document.

Download:
MiniGame-M0100 (module only)
MiniGame-T0100 (template example)
or  DemoQuest GiP Thread

Description
What does  this  module do that RunAGSGame doesn't do? If you were just going to activate the games from the very beginning each time then this module wouldn't be necessary.  However,  the usual scenario is that the player wants to return to the previous game and game state from where he left.  For example if the player plays an arcade game in a pub,  when he quits playing he ought to find himself in the same spot in the same pub where he was standing just before activating the arcade game.  The MiniGame module makes this as easy as pie.

Game Requirements
The main game and each mini game it calls must have been created with the same AGS version, color depth, and resolution.   All game files must be kept in the same folder.  The main game and all the mini games must use the same version of MiniGame and have Room0.crm be a black/blank room.

Passing Data
When a mini game is called it is often desired to pass data to it.   For example, in some situations it would be desireable to use the player's  money  to  make wagers in the mini game and then return the resulting winings or losses.  The MiniGame module uses a data dictionary to  pass  data to and from mini games. Each data point is associated with a unique name.  Data can be either a string or  an integer and is accessed through the following functions.

   MiniGame.sSet(String name, string value)
   MiniGame.iSet(String name, int value)
   MiniGame.sGet(String name)
   MiniGame.iGet(String name)

Calling a Mini Game
Mini games are called using the MiniGame.Call() function below.  The parameter 
FILENAME specifies the  name of the game file to be called.  It may or may not include file extensions of ".exe" or ".ags".

   // Call a mini game (from a room script or the global script)
   miniGame.iSet("Money",player.InventoryQuanity[iMone.ID]);
   MiniGame.Call("DemoCycle");

In this example, the amount of money in the player's inventory is passed to the mini game. The amount of money is stored in the data dictionary with a key of "Money". Next  "minigame.exe" is  called,  when it  terminates  it  will  return to "mainagame.exe".

Starting the Mini Game
The  mini  game will be loaded and then started as a result of the above MiniGame.Call(). The next thing to do is to determine if the game has been started from the operating  system or if it has been called. The function MiniGame.IsCalled() provids for this.  A value of  true is returned if called from another game and returns false otherwise.  This function is normally used in Global Script's game start event handler, game_start().

   // Mini Game Global Script
   function game_start() {

      // Mini Game startup script
      if (MiniGame.IsCalled()) {         // Read data dictionary
         Money = MiniGame.iGet("Money"); Passed from caller
      }
      else {                             // Run from OS
         Money = 10;                     // Give default amount
      }
   }

In the example above a global variable, Money, is set to the value stored in the data dictionary  under a key "Money" if the game has been called.  It is  set  to a value of 10 if the game was started from the OS.

Quitting a Mini Game
If  the  mini  game has been called then data must be saved in the data dictionary and the calling game re-activated. If the game has been run directly from the OS it can simply quit in the normal way using the QuitGame() function.  The preferred method of doing this  is to create a global function in the global script similar to the example below.  This  function is then called from any interaction functions designated as game exit or quit.

   // Mini Game Global Script
   function ExitGame(int ask_first) {
      MiniGame.iSet("Money",Money);      // Save data and ...
      MiniGame.Return(ask_first);        // return to caller
   }

In  the  example above  the global variable Money is  saved in the data  dictionary  via  MiniGame.iSet(). Next the MiniGame.Return() function  determines  if the  game  was  called  or  run  from the operating system. If the game was called then the  calling game is re-activated  and  the data in the data  dictionary is passed back.  If the game was run from the operating system then it's terminated normally using the AGS QuitGame() function.
 
Saving a Mini Game
The  MiniGame  module makes a call to the Game.SetSaveDirectory(). The specified directory name is formed by extracting the extension from the Game.  FileName string.If this extraction does not result in a useable  string then "SaveGames" is used instead. The success or  failure of  the Game.SetSaveDirectory() call should be checked before executing SaveGameSlot(), RestoreGameSlot(), DeleteSavSlot(), as follows..

   // Save the Game
   if (MiniGame.SaveAllowed()) {
      SaveGameSlot(slot);
   }
   else {
      Display("Error saving game, save directory not found");
   }

Perhaps a better  approach is to simply  remove the Save functions from the Gui at start up using Gui control prperties. 

   // Remove save functions if not allowed
   if (!MiniGame.SaveAllowed()) {
      gOptionsSave.Visible = false;    // Disable the Save button
      gOptionsRestore.Visible = false; // Disable the Load button
   }

Returning from a Mini Game
When  returning  from a mini game, any data it passes back must be read from  the data dictionary. This is done with a series of "if, else-if" statements  in  the  Global Script's repeatedly_execute() event handler function. The MiniGame.IsReturningFrom() function is used in the  conditional expression to determine which if any mini game has returned.
   
   // Main Game Global or Room Script
   function repeatedly_execute() {

      // Script to return from mini game
      if (MiniGame.IsReturningFrom("minigame.exe")) {
         Read data dictionary returned by mini game
         player.InventoryQuantity[iMone.Id] = MiniGame.iGet("Money");
      }
      else if (MiniGame.IsReturningFrom("anotherminigame.exe")) {
         Read data dictionary returned by another mini game
      }
   }

Any  data returned by the mini game can be retrieved and copied to the appropiate  game variables  using  the MiniGame.iGet() and the MiniGame.sGet() functions as shown above.

Note:  THIS MUST BE DONE IN THE REPEATEDLY EXECUTE HANDLER and not in the start game event handler because when returning from a mini game a  RestoreGameSlot()  operation is  performed to return to the point in the game from where the mini game was launched. This will overwrite  all game variables, so the data dictionary must be read after this occurs.  The  MiniGame.IsReturningFrom()  function will return true only after the restore opertion is complete. 

Known Issues
The following issues are known to the author, who can be contacted by posting on the AGS tech forum or by sending PM correspondance.

• Double Screen Transitions - As of this writing it is not possible to execute RestoreGameSlot() before the first screen is displayed.  This  was briefly mentioned above.  So instead of returning to the  screen from which the mini
  game was launched directly, it returns to  ROOM0 whoose background is  momentarily  displayed  before  the  desired screen is finally displayed  as a result of RestoreGameSlot()'s  execution.  To make this less noticable, ROOM0's background image is a single color of black and contains no script or interactions.  So when running directly from the OS ROOM0 is skipped and the game starts in another room as designated by the player character. When the game starts after returning from a call the GUI and mouse  are turned off and the player is left waiting in a black room.When the RestoreGameSlot() executes  the palyer is transported  to the room from where he called the mini game.
  
  Nested Calls
  Nested MiniGame.Call()s are  supported but have not been thourghly tested as of this release.  Should  someone try to do nested calls it is likely that it would work and that some issues would come to light.
  
  API Documentation
  A summary of this module's functions an Properties is given below.  There are three categories of functions as follows:
  
  
• Functions used in the calling game
       - MiniGame.Call()
       - MiniGame.IsReturningFrom()
  
  
• Functions used in the called game
       - MiniGame.Return()
       - MiniGame.IsCalled()
       - MiniGame.SaveSlot()
  
  
• Functions that are used in both
       - MiniGame.iGet()
       - MiniGame.iSet()
       - MiniGame.sGet()
       - MiniGame.sSet()
  
  static function MiniGame::Call(String filename)
  This function calls a mini game. The file containing the mini game must be in the same directory as the main game.  It must also have the same resolution and color depth as the calling game.  The file name of the mini game is  given by  the FILENAME parameter.
  
  Save slots  are numbered  from 0 to 999. The game restart function uses slot 999 so it is reserved. The call stack uses utilizes save slots 998 to 998 - MiniGame_STACKSIZE.
  
  In  debug  mode error messages are displayed if the specified game  files do not exist or if  the call  operation  cannot be completed.  When debug is  disabled these  messages are surpressed. In  either case the following error status is returned as follows.
  
     Return:
     eMiniGame_Ok                      - call complete successfully
     eMiniGame_MiniFilenameErr  - game file doesn't exist
     eMiniGame_MiniGameDatErr   - can't write to minigame.dat file
  
  static function MiniGame::IsReturningFrom(String filename)
  This function returns true if the game is starting up as result or returning from a previously called mini game. This fuinction is to be  called  from  the repeatedly_execute() function of the calling game to know when  to  copy  data  from  the memory buffer to game variables.
  
     Return:
     true                       - just returned from specified game
     false                      - did not return from specified game
  
  static function MiniGame::Return(int ask_first)
  This function is called from any interaction or custom function to return to the calling game or to quit if the game was started from the operating system.
  
  static function MiniGame::IsCalled()
  This function returns true if the game was started from the OS and returns false if it was called by another game or is returning from a called game.
  
     Return:
     false                      - game was started directly from OS
     true                       - game was called from another game
  
  static function MiniGame::SaveAllowed()
  This function returns true if a save directory was setup correctly.  It  returns  false  otherwise, in which case the main game and the mini games share the same save game space and would interfere with each other.  In  this  case the mini game should be prevented from executing SaveGameSlot() operations. 
  
     Return:
     false                      - prevent mini games from being saved
     true                       - allow mini games to be saved
  
  static function MiniGame::iGet(String name)
  This function returns the integer value corresponding to NAME.  If NAME doesn't exist an error mesage is generated.
  
  static function MiniGame::iSet(String name, int value)
  This function modifies value corresponding to NAME as specified by the VALUE integer parameter.  If NAME  doesn't exist the name-vale pair is appended to the end of the memory  buffer.  If there is no more room and error message is generated.
  
  static String MiniGame::sGet(String name)
  This function returns the string value corresponding to NAME.  If NAME doesn't exist an error mesage is generated and a null string is returned.
  
  static function MiniGame::sSet(String name, String value)
  This function modifies value corresponding to NAME as specified by the VALUE string  parameter.  If NAME  doesn't exist the name-vale pair is appended to the end of the memory  buffer.  If there is no more room and error message is generated.
  

The RestoreGameSlot() function seems to have no affect when executed from the game_start() event.  Is this by design or an oversight or am I missing something?  Is  it something that can be changed?   

*** Edit ***
Further investigation shows that this also happens when executing from repeatedly_execute() on the first execution.   

I have also noticed that there is a momentary blink of the screen when RestoreGameSlot() begins executing and before it transitions to the target room.

======
Why is this necessary?  I wish to use the RunAGSGame() featue to callup a mini-arcade game and then return to the original game.   So to return  to the same state in the original game from where I launched the mini-game I am using SaveGameSlot() just prior to launching the mini-game and RestoreGameSlot() after returning.   

In this case it is not desireable for intermediate screens/rooms to be displayed before returning to the original room in the main game. 

I am also having a problem calling the RunAGSGame() function from within a script module.   I have previously asked about this in the Beta thread and mention it here for completeness of the above explanation.

Thanks in advance for any help you can give. 

I came across this and thought some of the muscian folk may be interested (if they don;'t already know).  It also looks like a good place to find game music.  I haven't looked very deep yet.   Perhaps someone with a stronger interest and more time can take a look and let the rest of us know what's up (or down) with Opsound.

http://opsound.org/opsound.html

Does anyone have a copy of the original Demo Quest (i.e. the version prior to the gaes factory)?  If so would you be kind enough to put it up somewhere where I can download it.    Thanks.