INNEHÅLLSFÖRTECKNING

Projektpresentation................................................................................................... 3

Introduktion............................................................................................................................ 3

Sammanfattning....................................................................................................................... 4

Bakgrund................................................................................................................................... 4

Utvecklingsmiljö och Systemkrav...................................................................................... 4

Struktur................................................................................................................................... 5

Användargränssnitt................................................................................................................ 5

Systembeskrivning........................................................................................................ 8

Internationalisering av programmet................................................................................... 8

Inledning.................................................................................................................................... 8

Implementation.......................................................................................................................... 8

Grafiskt användargränssnitt................................................................................................ 9

Utseende..................................................................................................................................... 9

Funktionalitet........................................................................................................................... 9

Implementation........................................................................................................................ 10

Kommunikation mellan grafiskt gränssnitt och 3D-motor........................................... 11

Flygmotor.............................................................................................................................. 12

Translationer och rotationer av 3D-objekt.................................................................... 13

Inledning.................................................................................................................................. 13

ModifyTransform................................................................................................................... 13

Rotator.................................................................................................................................... 13

Translator.............................................................................................................................. 14

Dockningsfunktion............................................................................................................... 15

Inledning.................................................................................................................................. 15

Implementation........................................................................................................................ 15

Användarhandledning.............................................................................................. 18

Inledning................................................................................................................................. 18

Arbetsskärmen........................................................................................................................ 18

Systemmenyer.......................................................................................................................... 19

Välja språk.............................................................................................................................. 19

Hjälpfunktionen...................................................................................................................... 19

Ladda och Spara....................................................................................................................... 20

Bygga ett rymdskepp................................................................................................................ 20

Ångrafunktioner..................................................................................................................... 21

Kameravinkel och Zoomning................................................................................................... 22

Referenslista.................................................................................................................. 24

 


Projektpresentation

Introduktion

KTH har under våren 2002 genomfört kursen 2D1954 Programutvecklingsprojekt där en grupp studenter får ett projekt att utveckla och implementera. Projektet är vanligen initierat av lärare på KTH eller företag som behöver hjälp med en mindre programmeringsuppgift.

Denna rapport behandlar det projekt som tilldelades författarna. Inkluderade delar är en projektpresentation, en systembeskrivning och en användarmanual. Projektet heter Realtids-3D och är på initiativ av Göran Larsson och Lars O. Larsson. Det har registrerat varumärket UGMS[1]

Gruppen består av:

Martin Gülich, projektledare.

d99-mgl@nada.kth.se

William Saar, teknisk chef.

william@saar.ws

Niklas Vargensten, dagboksskribent, internationaliseringsansvarig, JavaDoc-ansvarig.

d99-nva@nada.kth.se

Anders Dahl, 3D-assistent.

d99-nva@nada.kth.se

Markus Orreteg, samordnings/delvis GUI-ansvarig.

orreteg@algonet.se

Fredrik Landes, 3D-assistent.

d99-nva@nada.kth.se

Stefan Gedal, dokumentationsansvarig, användarvänlighetskontrollant.

gedal@kth.se

Stefan Freyhult, GUI- och inställningsansvarig.

d99-sfr@nada.kth.se

WWW-dokumentation finns tills vidare på denna URL:

www.d.kth.se/~d99-mgl/prupp/html

Sammanfattning

Initiativtagarna till detta projekt är ett företag som tillverkar rymdskepp i moduler. Dessa moduler säljs som pedagogiska leksaker till barn i förskole- och lågstadieåldern.

Då en koppling mellan de fysiska leksakerna och ett motsvarande datorprogram med samma konstuktionsmöjligheter saknas, så har initiativtagarna vänt sig  till författarna med detta projekt.

UGMS handlar alltså i detta fall om att dynamiskt kunna bygga ihop ett rymdskepp ifrån ett antal olika moduler, t.ex. vingar, cockpit, bakdel osv., och på så sätt få ett eget rymdskepp precis som man vill ha det. Detta projekt går ut på att göra detta system tillgängligt i form av ett datorprogram.

Bakgrund

UGMS är ett system för att bygga ihop leksaksrymdskepp ifrån moduler. Idén bakom detta system unik och har stor potential. Detta ger stor möjlighet till variation och därmed tanke och intellektuell utveckling.

Vår uppgift var alltså att skapa ett dataspel baserat på varumärket UGMS. Vi skulle göra ett roligt program för barn i 6-9 årsåldern, där barnen kan välja mellan ett antal rymdskeppsmoduler och bygga ihop sitt eget rymdskepp. Tanken är att detta program ska komplettera en fysisk leksak som så småningom kommer att finnas på marknaden. Programmet kommer främst att fungera som en demonstration av möjligheterna till framtida datorspel baserat på samma idé.

Detta spel är tänkt att ge barnen en känsla för rumsuppfattning såväl i verkligheten som i en abstrakt datormiljö. Självklart får de också en ökad datorvana.

Utvecklingsmiljö och Systemkrav

Vi valde att använda Java som programspråk för utvecklingen av detta datorprogram. Främst därför att Java3D tillhandahöll det mesta som behövdes för att kunna göra en gedigen grund för manipulering av 3D-objekt som t.ex. en rymdskeppsmodul, men också för att Java kan användas till många olika dator-plattformar.

Programmet ska när det är färdigt kunna köras på en PC, närmare bestämt en äldre Pentium 2 (optimalt 300 MHz eller högre, och ett grafikkort med 3D-accelerator), eftersom programmet ska kunna vara tillgängligt för målgruppen på t.ex. en förskola.

Struktur

Systemet är indelat i tre delar: 3D-motor, användargränssnitt och internationaliseringsdelen. Den senare har hand om all texthantering i programmet och förenklar översättning och export av programmet till andra länder.

3D-motorn tillhandahåller sätt att manipulera 3D-objekt genom att lägga till, ta bort, markera och gruppera objekt i 3D-världen, rotera och translatera 3D-objekt samt ”docka” ihop olika 3D-moduler.

Användargränssnittet är den del som användaren ser. Här finns de menyer och knappar som användaren kan använda för att meddela sina kommandon till 3D-motorn.

Med hänsyn till målgruppen har vi valt att minimera andelen text som brukas i programmet, då en stor del av denna kan ha svårigheter att läsa och förstå skriven text. Användargränssnittet har istället lättförståeliga symboler för de essentiella kommandona.

Vårt stora problem var att få en fungerande grund för 3D-grafiken. Vi var tvungna att kunna visa rymdskeppsmodulerna i 3D, kunna rotera och translatera dem och så vidare. Det svåraste problemet var att ha någon slags kollisionsavkänning mellan modulerna till skeppet, dvs. att kunna ”docka” ihop två moduler med varandra. När vi väl löst dessa problem kunde vi göra ett pedagogiskt användargränssnitt anpassat för barnen. Under denna del av utvecklingen definierade vi en egen interaktionskomponent, en ratt med vilken man kan rotera ett 3D-objekt runt en axel.

Vi har inte hunnit testa programmet ”live” på barn i målgruppsåldern.

Det finns också en flygmotor med vilken man kan ta sitt ihopbyggda rymdskepp och flyga över ett landskap, dvs. ha lite kul med sitt skepp.

Användargränssnitt

Användargränssnittet är grafiskt och ger användaren möjlighet att utföra alla specificerade funktioner (se bild nedan).

Till vänster finns en modullåda med olika moduler. Dessa moduler kan man sedan använda i sitt rymdskepp genom att lägga till dem i 3D-världen. Detta görs genom s.k. ”drag&drop” funktionalitet, dvs. man klickar på en modul och drar den till 3D-fönstret.

Nertill finns en verktygslåda med funktioner för att manipulera 3D-världen. Man kan manipulera 3D-världen i två olika lägen, kameraläge och modulläge. Vilket läge som man befinner sig i visas av att bara en av lägesändrings-knapparna ses åt gången. I modulläge ser det ut som i första bilden nedan. Det finns två knappar för att translatera en modul in i skärmen och ut igen. Det finns en knapp för att docka ihop två moduler och en för att ta bort vald modul. Det finns tre rattar för att rotera modulen kring de tre axlarna. Längs till höger finns en knapp med en kamera på som visar att man genom att trycka på denna går in i kameraläge.

I kameraläge ser det ut som i den andra bilden nedan. Det finns två knappar för att zooma in och ut samt två rattar för att rotera kameran runt alla moduler samtidigt, vertikalt och horisontellt. I vertikalled kan man bara rotera kameran 180 grader (vända upp och ner), men i horisontalled kan man rotera kameran 360 grader (ett helt varv runt). Längst till höger finns nu en knapp med ett rymdskepp på som visar att man går tillbaka in i modulläge genom att trycka på denna.

Upptill finns en menyrad med olika funktioner som ändra språkinställningar. Här ska också finnas en hjälpfunktion som användarna kan vända sig till om de stöter på problem i användandet av programmet. Denna består ännu bara av en ”about”-ruta. Spara- och ladda-funktioner är ej implementerade i betaversionen.

Modulläge

Kameraläge


Systembeskrivning

Systembeskrivningen nedan är en närmare specifikation av de delar som nämndes tidigare under ¨Struktur¨. De områden som berörs är:

·      Internationalisering av programmet

·      Grafiskt användargränssnitt

·      Kommunikation mellan grafiskt gränssnitt och 3D-motor.

·      Flygmotor

·      Translationer och rotationer av 3D-objekt

·      Dockningsfunktion

Internationalisering av programmet

Inledning

Programmet ska enligt kravspecifikationen från uppdragsgivaren kunna stödja flera olika språk, och att det ska vara enkelt att anpassa programmet till användare från olika länder.  Java tillhandahåller grundläggande klasser för internationalisering, av vilka de viktigaste är klasserna ResourceBundle och Locale. Med hjälp av dessa har ett klasspaket som heter internationalization sammanställts.

Implementation

De främsta klasserna i internationalization är ett interface som heter LocalizedResourceProvider, vilket implementeras av klassen BasicLocalizedResourceProvider, och den abstrakta klassen LocalizeableResource, vilken ärvs av klasserna MediaResource (för bilder och ljud) och MessageResource (för textmeddelanden, vilka delas in i två subklasser).

 

 

 

 

 


UML klassdiagram för resursklasser

Tankegången är som så att då programmeraren behöver en resurs som klassas som Locale dependent, det vill säga den måste anpassas till användarens land och språk, får resursen inte hårdkodas. Resursen representeras istället av en instans av någon subklass till klassen LocalizeableResource (till exempel MessageResource), vilka alla finns samlade i de  klasser i själva programmets klasspaket som implementerar interfacet  LocalizeableResourceDeclarer (resurserna kategoriseras i klasser som till exempel ErrorMessages, InformationMessages, LabelTexts etc).

För att få fram den faktiska resursen (”localize it”) använder man en instans av typen LocalizedResourceProvider, med en resursrepresentationsinstans (LocalizeableResource) som argument. Genom att använda Java API-klassen ResourceBundle hämtar resurstillhandahållaren då den faktiska språkanpassade resurs som svarar mot den givna resursrepresentationsinstansen och den Locale som satts som instansvariabel för resurstillhandahållaren.

Vinsterna med internationaliseringen är stora vad beträffar programmets språkliga flexibilitet, men å andra sidan blir koden en aning mer omständlig. Det första steget är att finna alla ställen i programmet där språkberoende resurser som bilder och text ska visas för en användare, som till exempel menytexter, knapptexter, informations- och felmeddelanden, eventuella fel och exceptions som kan tänkas dyka upp då programmet körs, samt användarhjälp. Alla rader som berör dessa områden måste isoleras från övrig kod, och så kallad hårdkodad text, som till exempel 'setMenuText("Spara fil")' får inte förekomma.

Internationalisering är ett krävande extraarbete i programmeringen, men det underlättas tack vare att klasserna i paketet internationalization fungerar som en så kallad "black box" som endast tillhandahåller den information som den enskilde programmeraren behöver veta.

Grafiskt användargränssnitt

Utseende

Bilden nedan visar hur programmets användargränssnitt (GUI – Graphical User Interface) ser ut.

Till vänster finns en ram med en liten bild på varje modul som kan läggas till i programmet. Dessa kan man klicka på och ”dra över” till det stora fönstret där de då dyker upp och kan manipuleras. Nertill finns en ram med knappar, där det framför allt finns tre rattar för att rotera modulerna i tre dimensioner.

Funktionalitet

·      Lägga till: GUIt kan lägga till 3D-modeller av modulerna i ett rymdskepp genom s.k. ”drag&drop” ifrån ramen till vänster.

·      Rotera: rattarna nertill kan användas till att rotera modulerna när de lagts till.

·      Translatera: man kan flytta på moduler genom att klicka på dem och flytta runt dem med musen.

·      Kamera-/Modul-styrningsknappar som väljer om man vill styra kameran eller en enskild modul.

·      Zoomning: med dessa knappar kan man flytta moduler på djupet, eller om man har valt att styra kameran, zooma in och ut.

·      Papperskorgen: markera modulen och klicka på papperskorgen för att radera den

Implementation

GUIt är helt programmerat i Java och använder gränssnittet BuilderCallback, ett interface som vi tillverkat själva. Detta interface tillhandahåller metoder för att påverka 3D-grafiken genom t.ex. rotationer och translationer. Viktigast i detta gränssnitt är metoden void update( BuilderContext bc) som anropas varje gång framebufferten utritas på skärmen, dvs. 50 gånger i sekunden vid 50 Hz. Argumentet till denna metod är ett objekt av typen BuilderContext, vilket är ett annat gränssnitt som implementeras av den klass som har hand om 3D-grafiken. Genom att anropa metoder i denna klass kan man påverka 3D-världen som visas. För mer detaljer se java-dokumentationen i bilaga A.

Komponenter

·      Modul-ramen: Denna ram (till vänster) är av typen JScrollbar och innehåller en liten ikon för varje modul man kan lägga till. Eftersom den är en scrollbar kommer den att automatiskt utökas om alla moduler ej får plats i synområdet samtidigt. Modulerna själva är objekt av typen PartDescription.

·      Kontroll-ramen: Denna ram (nertill) är av typen JPanel. Rattarna i denna ram är objekt av typen RotationPane.  Det finns också några knappar som är objekt av typen JButton.

·      3D-displayen är ett objekt av typen Canvas3D. Denna klass implementerar gränssnittet BuilderContext som är kopplingen mellan det grafiska användargränsnittet och 3D-motorn på 3D-sidan.

·      Klassen CallbackDisplay implementerar gränssnittet BuilderCallback som är kopplingen på sidan med det grafiska användargränssnittet. Både BuilderContetx och BuilderCallback tillhandhåller ett bra sätt för klasserna till det grafiska användargränsnittet att kommunicera med 3D-motorn.

Skärmdump ifrån användargränssnittet

Kommunikation mellan grafiskt gränssnitt och 3D-motor

Då både det grafiska gränssnittet och 3D-motorn är grafiska komponenter som presenteras på skärmen är kopplingen mellan systemen förhållandevis tät. Kommunikationen mellan det grafiska gränssnittet och 3D-motorn sker genom att en callback-funktion i det grafiska gränssnittet anropas av 3D-komponenten före varje bildruta ritas ut. Under anropet ges det grafiska gränssnittet tillgång till ett gränssnitt genom vilket det kan manipulera 3D-motorn.

3D-motorn består av en scengraf och ett antal subsystem som arbetar mot scengrafen. Subsystem sköter inladdning, borttagning, förflyttning, rotation, hopsättning och särtagning av delar av scengrafen samt inladdning och lagring av hela scengrafen.

Flygmotor

Flygmotorn består också av en scengraf med en terrängnod samt en samling rörliga objekt. Flygmotorns ansvar är att i varje bildruta anropa samtliga rörliga objekt med tiden som förlupit sedan senaste bildrutan ritats ut, för att dessa ska kunna uppdatera sina positioner, riktningar samt eventuella animationer. Flygmotorn ansvarar även för att korrekt förflytta kameran på önskvärt sätt, främst genom att bakifrån följa ett utvalt rörligt objekt.

Varje rörligt objekt skapar och har själva tillgång till sin egen nodinformation i scengrafen. Genom att sätta in och manipulera transformnoder kan de rörliga objekten förflytta sig i scengrafens universum. Då de rörliga objekten själva har ansvaret för att uppdatera sig själva varje bildruta ankommer det också på dem att avläsa kommandon från tangentbordet, musen, nätverket eller andra kontrollenheter.

Terrängnoden är för tillfället statisk och behöver därför endast läsas in av flygmotorn. Det är dock möjligt att denna även kommer att behöva förändras, t.ex. genom en vyberoende terrängvisualiseringsalgoritm, och den kan i framtiden komma att utgöra sitt eget subsystem.

Translationer och rotationer av 3D-objekt

Inledning

För att förändra modellernas position och vinkel används två klasser gjorda för ändamålet. Klasserna är Rotator och Translator som bägge ärver från den abstrakta klassen ModifyTransform. Modellerna som modelleras (flyttas, roteras och kopplas ihop och ur) i programmet ligger i grup­per kallade transformgrupper.

ModifyTransform

ModifyTransform har implementerade metoder som används både i Rotator och Translator. Det finns även ett par instansvariabler. Modify transform anger att vid skapandet av en ny instans av de ärvande klasserna att kamerans transformgrupp måste anges. Kamerans transformgrupp behövs för att alla transformeringar ska vara kamerarelativa. Kamerarelativa transformationer används för att användaren ska uppleva att de olika transformationerna görs relativt till använ­daren.

Variabler:

modelGroup -   anger vilken transfromgrupp som modifieras av de ärvande klasserna

cam -          ger tillgång till kamerans vinkel

Rotator

Uför kamerareltiva rotationer av transformgrupper.

Den publika metoden rotateBy förändrar transformen för en transfromgrupp, givet vilken axel och antalet radianer rotationen rotationen avser. Axeln som rotaionen görs runt är relativ till kamerans vinkel vilket gör att rotationen i sig blir kamerarelativ.

Beräkningar

Innan rotation kan göras måste transfromgrupp väljas. Detta görs med en metod i ModifyTrans­form.

Givet:

·       vinkel i radianer

·       rotationsaxel;  X, Y eller Z (tolkas kamerans motsvarande axel)

Så utförs följande steg:

1.  Kamerans aktuella vinkeltransfrom C hämtas.

2.  Den valda transfromgruppens transform GC hämtas.

3.  Nollar translationen för modellens transfrom GC. Translationen ska vara densamma efter rota­tionen och ska således inte vara med när rotationen beräknas.

4.  Genom att transponera matrisen för kamerans transfrom C får man en rotationstransform CT från kamerareltaivt läge till identitetsrelativt läge. Den valda modellens transfrom, i identitetsrelativt läge, beräknas med matrismultiplikationen.
      GI= CTGC

5.  I det identitetsrelativa läget kan den önskade rotationen bräknas med den givna rotationsma­trisen R genom ytterligare en matrismultiplikation.
      GR=RGI

6.  Kamerareltivt läge måste åter beräknas
      GCR = CGR

7.  Translationen för modulen sättas tillbaka.

8.  Den nya transfromen sätts till modellens transfromgrupp.

Translator

Utför förflyttningar av modeller i förhållande till kamerans vinkel.

När modell blivit vald med metod i ModifyTransform kan modellens position förändras relativt kameran. Till metoden translate skickas en geometisk translationsvektor som beskirver förflytt­ning relativt kameran.

Beräkningar

Givet:

·       translationsvektor relativ till kamerans vinkel

Så utförs följande steg:

1.  Kamerans vinkeltransfrom C och modellens aktuella transform G hämtas från respektive trans­fromgrupper.

2.  Den givna translationsvektorn v läggs in i en transfromeringsmatris TV och roteras till kamer­arelativt läge TvC.
      TvC = CTv

3.  Den beräknade translationsmatrisen TvC används för att translatera den önskade modellen enligt vektorn v.
      GT=TvCG

4.  Den nya translaterade transformen GT sätts till modellens transfromgrupp.

Dockningsfunktion

Inledning

Användaren har som uppgift att genom musklick och rörelser translatera och rotera vingar, motorer och andra delar så att dessa tangerar varandra och bildrar en fullständig rymdskeppsstruktur (se figur 1). Systemets funktion är dels att låsa delarna till varandra då användaren fått dem att tangera men även för att underlätta för användaren så att han eller hon inte tvingas göra hela förflyttningen själv. Istället tar systemet över kontrollen när användaren placerat dem inom ett rimligt avstånd från varandra varpå en automatisk dockning sker.

Implementation

En dockning utgörs av en rotation och translation som placerar delarna i rätt position i förhållande till varandra (Se figur 2). Systemet är därför utformat så att mindre trådmodeller är fästade på ytan av de olika rymdskeppsdelarna. Dessa är utformade så att de sticker ut en bit från rymdskeppskroppen och på så sätt utgör sensorer som reagerar när andra sensorer kolliderar med dem. Dessa sensor-trådmodeller är helt transparenta och kommer inte vara synliga för användaren.  Sensorerna är endast utplacerade där man vill att rymdskeppets olika delar ska fästa till varandra.

När användaren förflyttat en rymdskeppsdel så att dess sensor kolliderar med sensorn för en annan del, så tas kontrollen över av systemet. En translation och en rotation sker som placerar objektet i rätt position (se figur 3). För att bibehålla de dockade delarnas positioner i förhållande till varandra måste även en omstrukturering av de två modulernas scengrafer göras. Scengrafen till den ena delen adderas till den andras och på så sätt kommer en translation/rotation att gälla båda delarna. I samband med ovanstående förfarande upplyses användaren om att dockningen lyckats.

Systemet ger också användaren möjlighet att lossa olika delar från varandra. Detta sker genom att användaren väljer en del genom att föra muspekaren över denna och klickar. Därefter klickar användaren på en knapp som lossar delarna från varandra. Lossningen sker genom att systemet translaterar delarna så att de befinner sig på ett lagom avstånd i förhållande till varandra samt att dess scengrafer separeras.

Beräkning av vinkelförändring

Vid dockning av modeller beräknas den rätta förändringen utgående från speciella transfromgrup­per som används vid dockningsdetektion. Dessa transfromgrupper är riktade i förhållande till modellens koppling så att de motsvarar han- eller honkopplingar.

Givet:

·       - mål transformgrupp (Goal)

·       - främmande transformgrupp (Foreign)

Så utförs följande steg:

1.  Detektionstransfromgruppernas (Goal och Foreign) transfromer beräknas i världsrelativa koordinater: Gw , Fw

2.  Vid beräkning av dockningsvinkeln nollställs målets Gw’s och den dockande transfromgruppen Fw’s translationer.

3.  Rotationstransfromen R, som beskriver dockningsrotationen, beräknas genaom att att utföra matrismultiplikationen R =       GwFwT

4.  Rotationen utförs genom multiplikation med modellens transfrom M enligt formeln M’ = MR

5.  M’ sätts till modellens transfromgrupp.

Nu har den dockande modellen fått den rätta vinkeln för att utföra dockningen och det återstår att beräkna förflyttningen av modellen så att målmodellen och den främmande modellens kopplingar hamnar mitt emot varandra.

Beräkning av positionsförändring    

1.  Vinkeln har uppdaterats och transformen Fw för den främmande dockningsdetektionstransformgruppen beräknas om i världsrelativa koordinater.

2.  Positionerna (f och g) för dockningsdetektionstransformgrupperna subtraheras för att erhålla translationsvektorn tfg mellan dem.
     
tfg = g - f

3.  För att möjliggöra interaktiv ihopkoppling hämtas riktningsvektorn k ifrån målets dockningstransfrom Gw. Vektorn k är z-axeln (tredje raden) i Gw och är riktad i ihopkopplingsriktningen av modellerna. Genom att multiplicera k med en skalär s  och addera k till tfg kan ett avstånd av längden s mellan modellerna åstadkommas.
      tfgk = tfg + sk

4.  Till den främmande modellens transfrom M’ adderas tfgk till den fjärde kolumnen i M’.
      M’’ = M’ + tfgk

5.  M’’ sätts till den främmande modellens transfromgrupp.

 

 

 

 

 

 

 

 

 


Användarhandledning

Inledning

Detta är en användarhandledning för de som vill använda programmet. Här beskrivs hur man kan bygga sitt eget rymdskepp genom att välja moduler från en lista, och sedan sätta ihop dem. Eftersom programmet är inriktat på barn i förskole- och lågstadieåldern är alla funktioner utformade för att vara så intuitiva som möjligt. Denna handledning är en hjälp för dig som vill förstå alla funktioner och få ut det mesta av programmet. De delar av programmet som tas upp i denna handledning är:

·       Arbetsskärmen

·       Systemmenyer

·       Välja språk

·       Hjälpfunktionen

·       Ladda och Spara

·       Bygga ett rymdskepp

·       Ångrafunktioner

·       Kameravinkel och Zoomning

Arbetsskärmen

Själva arbetsskärmen är uppdelad i tre delar. Till vänster finns en lista på de moduler som finns tillgängliga. Denna lista går att söka i genom att använda muspekaren för att flytta listan uppåt och nedåt.

Till höger finns själva arbetsfältet. Det är här som du sätter ihop ditt rymdskepp. Detta görs med några enkla handgrepp. Mer om detta under "Bygga ett rymdskepp".

I nederdelen av skärmen finns en så kallad toolbar, ett litet minitangentbord med knappar för de viktigaste funktionerna. Denna ändras beroende på vilket läge man befinner sig i.

Systemmenyer

Dessa finns i överkant i bilden. Klicka på en av rubrikerna för att få fram en lista med alternativ. Här finns ladda- och spara-funktioner, språkval och hjälpfunktioner.

Välja språk

Vid export av detta program till länder som inte talar vårt magnifika språk, kan det vara bra om möjligheten att byta språk finns. Det gör det nu, som tur är.

För att byta språk klickar man på ”Inställningar” i överkant på skärmen. Då visas en lista med olika inställningsalternativ. Klicka på ”Val av språk” och välj sedan det språk du vill byta till (i beta-versionen finns endast svenska och engelska tillgängliga).

Hjälpfunktionen

Hjälpfunktionen består av denna användarmanual, fast enkelt åtkomlig ifrån programmet.

För att använda hjälpfunktionen klickar du på ”Hjälp” i överkant på skärmen och väljer ”Användarmanual”.

Ladda och Spara

Om man tycker mycket om det rymdskepp man byggt, och vill kunna fortsätta att bygga på det vid ett senare tillfälle, så är det bra om man kan spara rymdskeppet för att sedan ladda det vid nästa session.

För att ladda och att spara så klickar man på ”Arkiv” i överkant på skärmen och väljer ”Ladda ett sparat rymdskepp” respektive ”Spara rymdskeppet”.

Bygga ett rymdskepp

För att ta fram en ny modul, så bläddrar man fram till den önskade modulen, klickar på den och håller ned vänster musknapp, samt drar modulen över till arbetsfältet. När man vill släppa modulen så släpper man vänster musknapp.

För att vrida en modul så att man kan sätta ihop den med en annan modul, så markerar man den genom att klicka på den med vänster musknapp. Sedan använder man sig av de tre rattar som finns i nederkant. Varje ratt styr rotationen runt en axel.

När man vridit modulen så att den ser ut att kunna passa in i den andra modulen, drar man ihop dem (på samma sätt som en modul flyttades tidigare). Passar de ihop så dockas de automatiskt, annars får man försöka igen. Detta förfarande upprepas tills rymdskeppet är klart.


Ångrafunktioner

Om man nu mot all förmodan skulle råka göra fel, så kan man givetvis ta isär rymdskeppet också. Man markerar delen av rymdskeppet som man vill ta bort genom att dubbelklicka på modulen, och sedan dra isär dem. Detta går endast att göra med moduler som bara sitter fast med en sida. den felaktiga modulen markeras och sedan trycker man på papperskorgen. Detta raderar den valda modulen (observera att denna funktion ej finns tillgänglig i testversionen av programmet). Detta går även att göra med "felvalda" moduler.

Kameravinkel och Zoomning

Man kan ändra kameravinkel genom att trycka på knappen med en symbol som ser ut som en kamera, och sedan använda rattarna för att rotera. Om man vill gå tillbaka till att rotera moduler trycker man på knappen med en modulsymbol. Knapparna till vänster används för att zooma in och ut, men när modulstyrningsläget är valt så används knapparna till att flytta moduler på djupet.


Referenslista

http://www.historyplace.com



[1] Ultimate Game Moduling System. All rights reserved, © Göran Larsson, Lars O Larsson / UGMS, 2002