Multiplayer Interactive-Fiction Game-Design Blog

15 Quests (cQuest)

Quests are a ubiquitous CRPG feature that is supported by Circumreality.

However, quests are handled slightly differently (and more powerfully)

in Circumreality than most CRPGs.

In Circumreality, a quest is really a hidden object that tags along in the

character's inventory. It receives all the PerceiveXXX() messages that

the character does, so it can monitor how many monsters were killed,

how many blueberries were picked, etc.

Unlike most CRPGs, Circumreality quests have a mind of their own. They are

their own object, and can do what they wish, including but not

limited to manipulating AIs. You can think of quests as "surrogate

dungeon masters" whose job is to tag along with the player and make

sure the game stays fun.

To create a quest, such as one in which the player must slay ten orcs:

1. Create a new class, such as "cQuestKillOrcs".

   
   
   




2. Derive cQuestKillOrcs from cQuest.

   
   
   




3. Fill in pNLPNounName and pNLPParseName for

   the name of the quest, "Bob wants you to slay 10 orcs".
   
   





4. Fill in pExamineGeneral with a description of the quest.

   This description will be displayed when the player is offered the quest,

   as well as when the player checks out his quest's status.

   
   
   



5. 
   
   pQuestPlayers should be set the the recommended number

   of players to complete the quest. If you don't set this, it

   will default to 1, indicating that the quest is good for solo play.
   
   




6. 
   
   pQuestTasks must be filled in with a list of tasks for

   the player to complete.

   
   
   

A final task of "Return to END-NPC." is automatically included.

You can disable this task, or change the string, by

changing pQuestTasksReturnToEnder.


7. Set pQuestRewardEnum to the list of rewards offered to the

   player when the complete the quest. They will be shown the rewards when

   they accept the quest too. The default value for the

   property is no reward except gratitude.
   
   


If any of your rewards are "special" rewards, that don't involve money

or objects, then you'll need to write

a QuestRewardSpecial() method.


8. You might wish to write your own QuestCanShare() method

   to control whether players can share quests amongst themselves. The

   default behavior allows sharing in most cases.

   
   
   

You might also want to do the following:

• 
  
  pQuestGiverSpeak controls what the guest giver says when

  it hands out the quest.

  
  
  



• 
  
  pQuestGiverGive will cause the quest giver to hand

  out items to the player, such as a letter that must be

  delivered. pQuestGiverSpeakAfterGive has the NPC speak

  a phrase after it has given the object(s) to the player.

  
  
  




• You may wish to set pQuestEnder to the NPC that the player

  needs to talk to in order to complete the quest. If you leave this

  as Undefined, then the player will need to return to the quest giver.

  If this is NULL, the player doesn't need to talk to anyone, and can

  complete the quest anywhere.

  
  
  



• 
  
  pQuestEnderContextMenu is a string that's displayed in

  the pQuestEnder NPC's context menu that allows the player to finish

  the quest. The defaults to something like, "I'm done with the quest".
  
  


The NPC's reply is controlled by pQuestEnderSpeakOnCompleted.

It has a default.




• If the quest ender requies a set of objects from the player in order

  to complete the quests, then fill the objects

  in pQuestEnderTake. You may also wish to

  fill pQuestEnderSpeakBeforeTake with a phrase that the NPC

  speaks before it takes the objects, like "I'll be taking your foozle skins now."

  
  
  




• If the player completes the quest, starts talking to the pQuestEnder NPC,

  but doesn't mention pQuestEnderContextMenu, then the NPC will eventually

  bring up the fact that the player has completed

  the quest. Set pQuestEnterQuestionOnCompleted to the string.

  It defaults to something like, "So you completed the quest! What reward would

  you like?"
  
  





• When the player finally selects a reward, the quest is completed.

  The NPC will then speak pQuestSpeakOnCompletion with

  something like, "Thank you for completing the quest."

  
  
  




• To have the quest ender automatically offer another quest,

  set pQuestEnderOfferMoreQuests to TRUE, which is the

  default.
  

  
  




• If you want your quest to be hidden from the player,

  set pIsInvisible to TRUE. You wouldn't normally have an

  invisible quest since then players couldn't cancel it. However, if

  the quest is acting like an invisible dungeon master, this might

  be a good idea.

  
  
  




• Unlike most CRPGs, there are consequences to a player cancelling

  a quest. The most common one is that the quest giver will dislike

  and/or distrust the player for cancelling the quest.

  Adjust pQuestCancelledLike to control how much the

  quest giver's opinion of the player character is affected if the

  player cancels the quest.
  
  





• Change pQuestCancelCoolDown to control how long

  the player must wait before they can re-accept a cancelled quest.
  
  




• 
  
  pQuestCompletedSpeak is spoken by the narrator when the

  quest is finished. If left blank, a default phrase is spoken.

  
  
  




• Conversely, pQuestCompletedLike increases the quest

  giver's like and trust when the quest is completed.
  
  




• 
  
  pQuestCompletedReputation affects the PC's reputation

  when the quest is completed.

  
  
  




• By default, all quests will identify all "involved" NPCs to the

  player's characters so that when the player sees the NPC, he

  will have a name associated with it. This makes life easier for

  the player since they don't have to wander around the world

  asking NPCs their names. The NPCs are gotten from pQuestGiver,

  pQuestEnder, and any "MapToObject" listed in QuestTasks(). If

  you don't wish to automatically identify NPCs then

  set pQuestAutoIdentify to FALSE.
  
  





• If you provide pQuestKnowledgeAnecdote then the player

  can brag about his exploits on the quest to any NPC he may meet.

  This bit of knowledge can be used by the player when trading stories

  and rumors with NPCs.
  
  





• Setting pQuestFracture will cause

  PlayerCharacter.FractureAdd (pQuestFracture) to be called if

  the player completes the quest. Thus, a quest to slay the orcs

  will result in a happy village without any fires burning.
  
  




• 
  
  pQuestAutoComplete lets the quest automatically

  end without having to see a NPC.

  
  
  




• If your quest object has properties that it needs to initialize

  when it's first created and assigned to a player, then

  write your own QuestInit().

  
  
  




• If you quest needs special clean-up, then write your

  own QuestEnd().
  
  





• You might write your own QuestTasks() method. This returns

  a list of all the tasks that the player must complete in the quest,

  as well as a percent-done for each task. The tasks are displayed

  in the quest information page. The default code looks at

  pQuestTasks and derives a list.

  
  
  




• If you use pQuestTasks and provide your own callbacks, you

  may need to call QuestTasksBoundary() from time to time

  to ensure that the player isn't allowed to "work ahead" on a task.

  
  
  




• Write your own QuestAIConversation() method to

  allow NPCs that are involved with the quest to interpret sentences

  spoken to them by the player. For example: If one task in your

  quest is to talk to Fred and get some information from him, you

  would provide a QuestAIConversation() method to return the

  string's that player could speak to Fred, such as "do you have [any]

  (information|info) for me".

  
  
  




• Write your own QuestAIQuestionAdd() method so

  that NPCs that are involved in the quest can bring up quest

  information in their conversations with the player. As in the

  example above, if the player doesn't mention that they are

  looking for information, Fred might eventually bring it up.

  
  
  




• If you use either QuestAIConversation() or QuestAIQuestionAdd() you

  will need to provide QuestAICallback() to have the

  NPC speak the phrase, and/or take actions.

  
  
  



• 
  
  QuestAIShowOffer() and pQuestAIShow and pQuestAIOffer can

  be modified to control how pQuestEnder responds when shown or given one

  of the objects needed to complete the quest.
  
  





• You may wish to override QuestCanBeCompleted(), but

  you probably won't need to.
  
  




• 
  
  QuestPercent() can be overridden, but as long as your

  QuestTasks() list is accurate, QuestPercent() will work fairly well.

  
  
  




• The default implimentation of QuestRewardEnum() returns

  pQuestRewardEnum. If you need more control than this then override

  QuestRewardEnum().

  
  
  



• 
  
  pQuestCanCancel can be set to FALSE to prevent the quest from

  being cancelled, or you can write your own QuestCanBeCancelled() method.

  
  
  




• If you want to keep statistics about how long a quest took to complete

  or when players started/stopped the quest, then create statistics objects

  based on cStatisticsQuestDuration and/or cStatisticsQuestStartStop and

  reference the object(s) in pQuestStatistics.
  
  

Quest objects also contain some useful properties that you don't need

to initialize, but which might be handy during your coding:

• 
  
  pIsQuest is set to TRUE, identifying the object

  as a quest.

  
  
  



• 
  
  pQuestClass is the class name of the quest, "cQuestKillOrcs".
  
  



• 
  
  pQuestGiver is the NPC that gave the player the quest.
  
  



• 
  
  pQuestStartedPlayTime is the number of hours the player had

  played his characters when the quest was begun. You can use this

  for timed quests, or penalties for taking too long on a quest.
  
  




• 
  
  pQuestStartedTime is the time from TimeGet() when the quest

  was begun.

  
  
  



• 
  
  pQuestStoryline is the storyline object (based on cStoryline)

  that this quest is part of.

  
  
  

There are two ways to give a quest to a player character:

1. You can call cCharacter.QuestsAdd() to add the quest to the player's

   list of quests.
   
   


While you're looking at QuestsAdd(), you might also wish to look

at QuestsEnum(), QuestsFind(), QuestsRemove(),

pQuestsCancelled and pQuestsCompleted.


2. You figure out which NPC hands out the quest and modify some

   properties of the NPC so it will hand out the quest. See below.
   
   

To easily have a NPC hand out a quest:

1. Set pAIQuestHandout to a list of all the quests that the

   AI hands out, as well as information about requirements like previous

   quests that must have been completed.

   
   
   

You can get a bit more control by modifying:

1. 
   
   pAIQuestQuestionAdd controls questions/statements the NPC

   might make based upon whether a quest has been completed or not. For

   example: If the player hadn't yet accepted the "kill 10 orcs" quest, the

   NPC (as well as every NPC in the village) might mention that orcs

   were troubling the village. When the player accepts the quest, a different

   line might be used. And finall, after the player finishes the quest,

   NPCs might occasionally thank the player for defeating the orcs. Likewise,

   if the player cancels the quest, the player might get some verbal abuse.

   
   
   



2. 
   
   AIQuestHandOut() gives you more control over the quests

   that a NPC hands out than pAIQuestHandOut.

   
   
   



3. 
   
   AIQuestHandOutUI() brings up a dialog that allows players

   to accept a quest that the NPC is providing. You probably won't need

   to override this, although you may wish to call it at some point.
   
   




4. 
   
   AIQuestQuestionAdd() provides even more control than

   pAIQuestQuestionAdd.

   
   
   

• The QuestUI() function brings up a dialog for displaying

  the player's quests, or displaying information about a specific quest.
  
  




• 
  
  cCharacter.QuestsCompletedOrCancelled() can be used to

  determine if a player character has completed (or cancelled) a quest.

  
  
  

Quests can take advantage of a sub-system called "the rumor mill".

The rumor mill causes NPCs to talk to one another about the quest, either

spurring the player's interest in the quest (if they haven't accepted it),

or talking about the quest's completion (assuming that the player has

completed it).

The rumor mill is a useful technique because:

1. It make the quest feel important before players have heard about

   the quest or accepted it. For example: NPCs might say to one another,

   "I just saw another rat this morning!", "Yes, I know what you mean; They're everywhere!"

   
   
   




2. Once players have completed the quest, NPCs will comment about

   their accomplishments. For example: "Thank god all the rats are gone!",

   "<PC-Name> certainly did a good job."

   
   
   

To modify a quest to use the rumor mill:

1. Create a conversation script based on cConvScriptRumorMill which

   described the "There's a plague of rats" conversation between NPCs. For more information,

   see the cConvScript tutorial.

   
   
   




2. You may want to set pConvScriptAutoNPCs and pConvScriptAutoListenersExclude so

   that only certain NPCs will discuss the rumor, or so that NPCs won't talk about another NPC

   if that NPC is present.

   
   
   

For example: If the quest is about spying on the strange activities of NPC X, then NPCs won't discuss

the rumor while NPC X is in the room.




3. In the quest object, set pQuestRumorMillConvScriptsNotStarted to the conversation

   script object that you just created.
   
   





4. You might also wish to create several other conversation scripts and assign them

   to pQuestRumorMillConvScriptsActive, pQuestRumorMillConvScriptsCompleted,

   and pQuestRumorMillConvScriptsCancelled. These control what NPCs will say to one another

   once the quest has been accepted (but not completed), after it has been completed,

   or after it has been cancelled.

   
   
   




5. If you want the quest's rumors to spread beyond the map where the quest is handed out,

   then set pQuestRumorMillMap to a list of maps where the rumors will be discussed.

   If you leave it blank, then the map where the NPC hands out the quest will be used.

   
   
   

That's all you need to do.

If you want to include rumors outside of the quest, then:

1. Fill in pRumorMillSource in the NPC with a list of rumors.

   
   
   




2. Optionally, fill in pRumorMillSourceMap with the map where the rumor

   will be spoken.
   
   





3. Or, write your own RumorMillSource() method for the NPC.

   
   
   




4. Or, write your own RumorMillConvScripts() method layer, assigned to the player

   characters. You can test for whatever conditions you like (such as different fractures) and

   add rumor-mill conversation scripts.

   
   
   

You might also wish to change the following:

• 
  
  gRumorMillLastTime and gRumorMillSpokenTime affect how often rumors

  are spoken, ensuring that players don't hear them too often.

  
  
  

16 Shape chaging

Magically changing a player character's shape... transforming them into frogs and whatnot.

Shape changing

A fairly common fantasy device is to change a character's shape,

such as turning them into forgs, mice, or bowls of petunias.

Shape changing layer

Before you even think about changing a character into a frog (or whatever),

you need to create a special class, such as cShapeChangeFrog, that

contains code and properties describing the essense of what makes a frog

different from a man (or elf, dwarf, etc.)

To create a shape changing class:

1. 
   
   Create a new class in the usual way. Make sure that

   it is not instantiated as an object. Give it a name,

   such as cShapeChangeFrog.
   
   





2. Base the class off of cShapeChange.

   
   
   




3. In cShapeChangeFrog, write code

   to override some important methods, such

   as NameRace(). See below for more information.

   
   
   




4. Add some properties that you need to override,

   such as pBodyParts or pHeight. This is a tricky situation.

   See below for more details.

   
   
   

When a character is changed into a frog, the cShapeChangeFrog class

is layered on top of their character's existing class.

(They layering is done using a call to LayerAdd().) This layer

intercepts all method and property calls made to the character's object.

If the layer happens to have the given method, that's called instead

of the main object's method.

Likewise, if the layer has a specific property, then that property

is used instead of the character's property (kind of... see below).

You may wish override one or more of the following methods in

your cShapeChangeFrog class:

• 
  
  EmoteQuery() - Use this to limit or change the emotes

  that the changed character can do. A frog may not be able to smile,

  but it can "ribbit". (You may also need to add an extra emote command, "ribbit",

  to allow the character to type the emote.)

  
  
  



• 
  
  HeightEye() - Override this if the character can fly.
  
  



• 
  
  NameRace() - Returns the race's name, such as "a frog".

  If you don't replace this, the character may still be known as "an elf" or

  "a dward".
  
  




• 
  
  StealthAutoHide() - Causes the transformed character not

  to be noticed right away.

  
  
  



• 
  
  VisualEmoteEnum() - Override this to control what visual

  emotes a character can make, perhaps eliminating "smile" and adding

  "throat sack full".
  
  




• 
  
  VisualEmoteQuery() - Change this along with VisualEmoteEnum().
  
  



• 
  
  VisualModifierEnum() - Change this along with VisualEmoteEnum().

  This method converts from an emote into morph shapes used in the character's

  3d model.
  
  

You will also need to add several properties to cShapeChange frog.

However, because this is a layered class added after the main object

has been created, any values you type into the properties' edit

fields will be ignored. The only way to actually change

the value is to check the "Get/Set" checkbox next to the property and

write your own Get() method.

For example: You want your frog to be 1/10th of a meter tall.

Normally, you'd set "pHeight" to 0.1. This won't work. Instead:

1. 
   
   Add the pHeight property as normal.
   
   



2. 
   
   Leave the pHeight edit field blank. It won't make any difference.
   
   



3. 
   
   Check the "Get/Set" checkbox.
   
   




4. Edit the "Get" code by pressing the "Get" button next

   to the property edit field. The

   default code will be "return pHeight". Change this

   to "return 0.1;".
   
   





5. You can leave the "Set" code alone. There's no point changing

   it.
   
   

You will need to write code for a number of properties. You may wish

to change once or more of the following:

• 
  
  pBodyParts - Controls what limbs your character has.

  Be aware that you may need to create special body parts

  for the shape change; frogs legs are different than human legs.
  
  




• 
  
  pContainerItemsMax - The maximum number of items the character

  can hold.

  
  
  



• 
  
  pContainerVolumeMax - The maximum volume of items the character

  can hold.

  
  
  



• 
  
  pContainerWeightMax - The maximum weight of items the character

  can hold. This is affected by the character's strength attribute.

  
  
  



• 
  
  pExamineGeneral - What other players hear if they examine

  the shape-changed character.

  
  
  



• 
  
  pGender - If you want to do gender bending.
  
  



• 
  
  pHeight - The character's height.
  
  



• 
  
  pSkillsFemaleInnate and pSkillsMaleInnate - How male/female

  versions of the shape differ.

  
  
  



• 
  
  pSkillsRacialInnate - Skills that the player automatically acquires

  when they're turned into this shape. This might, for example, include improvements

  to jumping as well as the ability to speak to other frogs.
  
  


Important: Skills from pSkillsRacialLeanred are kept when a

character is shape changed. That means that if oSkillElvish is part

of pSkillsRacialLearned, then when the character is transformed into

a frog, they will be able to speak Elvish. If you don't want this

to happen, you could either add a negative Elvish skill to

cShapeChangeFrog.pSkillRacialInnate, or you could make Elvish an

innate skill instead of a learned one.


• 
  
  pVoice - The character's voice; frogs might have a croaky voice.
  
  



• 
  
  pVolumeSelf - How much volume the character uses.
  
  



• 
  
  pWeightSelf - How much the character weighs.
  
  



• 
  
  pDamageScreamBig, pDamageScreamHuge,

  pDamageScreamSmall, and pDamageScreamWince - What sounds the character

  makes when it's hit, probably a croak.
  
  




• 
  
  pFOVRange360 - The character's field of view.
  
  



• 
  
  pHandedness - Force the character to be left/right handed.
  
  



• 
  
  pThreeDSound - How the player hears sound when playing

  the shape-changed character.

  
  
  



• 
  
  pVisualEffectAutoExposure - How well the shape-change sees at night.
  
  



• 
  
  pVisualEffectColor - How colorful the world looks.
  
  



• 
  
  pVisualEffectColorBlind - Make the shape-changed

  character color blind.

  
  
  



• 
  
  pVisualEffectNearSighted - Make the shape-changed

  character near-sighted.

  
  
  



• 
  
  pVisual - A 3D model of what the shape-changed character

  looks like.

  
  
  

Changing a character's shape

Once you've done all that, actually changing the character's shape is

pretty easy:

1. You can call ShapeChangeQuery() to get the character's

   current shape.
   
   





2. Before changing the shape, find out what room the character is

   in and call vRoom.RoomShapeChange(). This is a safety

   check to ensure that characters won't be changed into shapes that

   aren't suitable for the room.
   
   


For example: Part of the game might involve changing player characters

into mice and letting them run through the walls of a building. While

a player is in the wall, you don't (usually) want them to change back into a human.

For one, how would you draw the inside of a wall from the perspective

of a human?


3. Call ShapeChange() to change the shape. The function

   takes parameters specifying what's to happen with the character's equipment.
   
   





4. You should use SpeakNarratorAll() to inform everyone in the

   room that the shape change has occurred.
   
   

Miscellaneous

• As alluded to above, if you want rooms, maps, regions, or zones where

  the player is forced into a specifc shape (or forced out of a shape),

  then write your own RoomShapeChange() for the room, map,

  region, or zone object.
  
  

17 Stealth

How sneaking about works.

Stealth

Circumreality allows PCs and NPCs to sneak around through various commands

like "Sneak DIRECTION", "Hide", and "Hide behind OBJECT". Sneaking

allows characters to avoid enemies as well as listen in on conversations.

For the most part, sneaking is auomatically handled by:

• 
  
  oSkillStealth helps make characters more stealthy.
  
  



• 
  
  oSkillPerception improves a character's ability to find

  hidden characters.

  
  
  



• 
  
  IsThereLight() affects how dark it is, and how

  well characters can hide.

  
  
  




• If an object's pVolumeSelf is high enough (a few times

  higher than the character's volume), then the object can be hidden

  behind (or in).

  
  
  

Objects/rooms that can hide in

If you want to ensure that characters can hide behind an object, or hide in

a room:

• Set pVolumeSelf for objects such as crates, dressers, or

  anything that a character might wish to hide behind or in.
  
  





• If pVolumeSelf isn't good enough, you can write your

  own StealthHidingPlaceQuality() method for the object. For example:

  If you wanted to allow players to hide under a pile of leaves,

  you'd need to write this.
  
  





• If you have a room that you want to make it easy to hide in, without

  having to hide behind an object, write your

  own StealthHidingPlaceQuality() for the room. For example: If the

  room is very smokey then hiding would be easy.
  
  

How it works

1. Whenever a character hides, their pStealthHidden property

   is set to indicate the object they're hiding in/behind, as well

   as how they're hiding.

   
   
   




2. If any characters come into the room where a character is hiding, or

   if they search the room, StealthIsHiddenPerceived() is called.

   ActorMove() automatically handles this.

   
   
   




3. If one character is hidden to another, then the

   hiding character's pStealthHiddenTo is expanded to

   include the character that can't see the hiding character.

   
   
   




4. When a character is listed in pStealthHiddenTo, calls

   to IsHidden() will return TRUE for that character.
   
   





5. Whenever the hidden character performs an

   action, ActionVoidStealth() is called, potentially

   exposing the hiding character. This, in turn,

   calls StealthIsHiddenPerceived().
   
   





6. NPCs that perceive a character sneaking around,

   with PerceiveActorEnter(), PerceiveActorLeave(),

   and PerceiveInNewRoom() will mistrust the character.

   
   
   

Miscellaneous

• If you want specific characters not to be noticed by

  other characters, write a StealthAutoHide() method

  for the character.

  
  
  

Download 8.87 Mb.

Share with your friends: