3D Game Programming All In One (2004)

268Chapter 7 ■ Common Scripts

actual chat message in a tagged string. The rest of the parameters are not actually acted on

so can be safely ignored for now. The parameters are passed on to the pseudo-handler OnChatMessage. It's called a pseudo-handler because the function that calls OnChatMessage is not really calling out from the engine. However, it is useful to treat this operation as if a callback message and handler were involved for conceptual reasons.

The next function, ClientCmdServerMessage, is used to deal with game event descriptions, which may or may not include text messages. These can be sent using the message functions in the server-side Message module. Those functions use CommandToClient with the type ServerMessage, which invokes the function described next.

For ServerMessage messages, the client can install callbacks that will be run according to the type of the message.

Obviously, ClientCmdServerMessage is more involved. After it uses the GetWord function to extract the message type as the first text word from the string %msgType, it iterates through the message callback array ($MSGCB) looking for any untyped callback functions and executes them all. It then goes through the array again, looking for registered callback functions with the same message type as the incoming message, executing any that it finds.

The next function, addMessageCallback, is used to register callback functions in the $MSGCB message callback array. This is not complex; addMessageCallback merely steps through the array looking for the function to be registered. If it isn't there, addMessageCallback stores a handle to the function in the next available slot.

The last function, DefaultMessageCallback, is supplied in order to provide an untyped message to be registered. The registration takes place with the line after the function definition.

A Final Word

The common code base includes a ton of functions and methods. We have only touched on about half of them here. I aimed to show you the most important modules and their contents, and I think that's been accomplished nicely. For your browsing pleasure, Table 7.2 contains a reference to find all the functions in all common code modules.

Team LRN

A Final Word 269

Table 7.2 Common Code Functions

continued

Team LRN

270 Chapter 7 ■ Common Scripts

common/client/metrics.cs FpsMetricsCallback TerrainMetricsCallback VideoMetricsCallback InteriorMetricsCallback TextureMetricsCallback WaterMetricsCallback TimeMetricsCallback VehicleMetricsCallback AudioMetricsCallback DebugMetricsCallback Metrics

common/client/mission.cs ClientCmdMissionStart ClientCmdMissionEnd

common/client/missionDownload.cs ClientCmdMissionStartPhase1 OnDataBlockObjectReceived ClientCmdMissionStartPhase2 OnGhostAlwaysStarted OnGhostAlwaysObjectReceived ClientCmdMissionStartPhase3 UpdateLightingProgress SceneLightingComplete

common/client/recordings.cs RecordingsDlg::onWake StartSelectedDemo StartDemoRecord StopDemoRecord DemoPlaybackComplete

common/client/screenshot.cs FormatImageNumber RecordMovie MovieGrabScreen StopMovie DoScreenShot

common/server/audio.cs ServerPlay2D ServerPlay3D

common/server/clientConnection.cs GameConnection::onConnectRequest GameConnection::onConnect GameConnection::setPlayerName IsNameUnique GameConnection::onDrop GameConnection::startMission GameConnection::endMission GameConnection::syncClock

GameConnection::incScore

continued

Team LRN

Team LRN

272 Chapter 7 ■ Common Scripts

common/server/missionLoad.cs LoadMission LoadMissionStage2 EndMission ResetMission

common/server/server.cs PortInit CreateServer DestroyServer ResetServerDefaults AddToServerGuidList

RemoveFromServerGuidList OnServerInfoQuery

common/ui/ConsoleDlg.gui ConsoleEntry::eval ToggleConsole

common/ui/GuiEditorGui.gui GuiEditorStartCreate GuiEditorCreate GuiEditorSaveGui GuiEditorSaveGuiCallback GuiEdit

GuiEditorOpen

GuiEditorContentList::onSelect

GuiEditorClassPopup::onSelect

GuiEditorTreeView::onSelect

GuiEditorInspectApply

GuiEditor::onSelect

GuiEditorDeleteSelected

Inspect

InspectApply

InspectTreeView::onSelect

Tree

GuiInspector::toggleDynamicGroupScript

GuiInspector::toggleGroupScript

GuiInspector::setAllGroupStateScript

GuiInspector::addDynamicField

InspectAddFieldDlg::doAction common/ui/LoadFileDlg.gui FillFileList

GetLoadFilename common/ui/SaveFileDlg.gui GetSaveFilename

DoSACallback

SA_directoryList::onSelect

SA_filelist::onSelect

Team LRN

One last thing to remember about the common code: As chock-full of useful and important functionality as it is, you don't need to use it to create a game with Torque. You'd be nuts to throw it away, in my humble opinion. Nonetheless, you could create your own script code base from the bottom up. One thing I hope this chapter has shown you is that a huge pile of work has already been done for you. You just need to build on it.

Moving Right Along

In this chapter, we took a look at the capabilities available in the common code base so that you will gain familiarity with how Torque scripts generally work. For the most part, it is probably best to leave the common code alone. There may be times, however, when you will want to tweak or adjust something in the common code, or add your own set of features, and that's certainly reasonable. You will find that the features you want to reuse are best added to the common code.

As you saw, much of the critical server-side common code is related to issues that deal with loading mission files, datablocks, and other resources from the server to each client as it connects.

In a complementary fashion, the client-side common code accepts the resources being sent by the server, and uses them to prepare to display the new game environment to the user.

So, that's enough programming and code for a while. In the next few chapters, we get more artistic, dealing with visual things. In the next chapter, we will take a look at textures, how to make them and how to use them. We'll also learn a new tool we can use to create them.p

Team LRN

This page intentionally left blank

Team LRN

chapter 8

Introduction to

Textures

3D computer games are intensely visual. In this chapter we begin to explore the creative process behind the textures that give 3D objects their pizzazz.

Using Textures

Textures are probably the unsung heroes of 3D gaming. It is difficult to overstate the importance of textures. One of the most important uses of textures in a game is in creating and sustaining the ambience, or the look and feel of a game.

Textures also can be used to create apparent properties of objects, properties that the object shape doesn't have—it just looks like it does. For example, blocky shapes with jutting corners can appear to be smoothed by the careful application of an appropriate texture using a process called texture mapping.

Another way textures can be used is to create the illusion of substructure and detail. Figure 8.1 shows a castle with towers and walls that appear to be made of blocks of stone. The stone blocks are merely components of the textures applied to the tower and wall objects. There are no stone blocks actually modeled in that scene. The same goes for the appearance of the wooden boards in the steps and other structures. The texture gives not only the appearance of wood but the structure of individually nailed planks and boards. This is a powerful tool, using textures to define substructures and detail.

This ability to create the illusion of structure can be refined and used in other ways. Figure 8.2 shows a mountainside scene with bare granite rock and icefalls. Again, textures were created and applied with this appearance in mind. This technique greatly reduces the need to create 3D models for the myriad of tiny objects, nooks, and crannies you're going to

275

Team LRN

Team LRN

Team LRN