Commits

Anonymous committed a2edc42 Merge

merged bach.

  • Participants
  • Parent commits af1e150, 02b7f61

Comments (0)

Files changed (4)

 
 TODO: Add doctests, since it begins to become more complex... 
 
+Plans: 
+    - Simple to use functions in easy to read scriptfiles in the style of the ministory file. 
+    - char.compete(other, skill_name) -> See who wins and by how much. 
+
+Ideas: 
+    - Lazy loading modules, to be able to print stuff at once without having to print before the imports.
+    - Add getting experience for groups and show the chars together (only one experience header instead of one per char). 
+
+
 Basic design principles for the scripting language: 
     
     - The action is character centered wherever possible and useful. 
       This means: Doing it this way makes the scripts appear more natural (to me). 
       Also this allows story() to rearrange the order of passed arguments, if all get passed in one step -> a simpler way to say "new scene". 
 
+
 This (and other) code can be found at U{http://freehg.org/ArneBab/textrpg}
 
 Doctests: 
 # __date__      = '7th March 2007' 
 __url__       = 'http://rpg-1d6.sf.net' 
 
-
 __version__   = '0.1' 
 
 from textrpg_1d6 import Char as ews_char
 from time import sleep # for autoscrolling
 
-
 ### Classes ###
 
 class UserInteraction(object): 
             sleep(0.1)
             sleep((len(text) - 1)*0.1)
 
-
 class Dialogs(object): 
     """Basic dialogs. 
     
         return won, [deep_wounds_self, critical_wounds_self, self.damage_self], [deep_wounds_other, critical_wounds_other, self.damage_other]
     
 
-
 class Story(UserInteraction, Dialogs): 
     """The main component for telling stories. Subclass this to change all behaviour."""
     def __init__(self, *args, **kwds): 
             for i in data.split("\n"): 
                 self.diag(i, localize=False, *args, **kwds)
     
-    
     def save(self, chars=[], *args, **kwds):
             """Save the current state."""
             for i in chars:
                     i.save()
     
-    
     def give_exp(self, char, amount=0): 
         """Give experience to only one char."""
         for i in self.get_experience([char], amount=amount).splitlines(): 
-            diag(i)
+            self.diag(i)
 
 
 class MissingScriptingFunction(Exception): 
                     + "\n\nstory_helper = Story()\n" \
                     + self.implementation
         
-    
 
 ### Functions ###
 

ministory.py

File contents unchanged.
     - In the story function, an action is a parameter of the story. 
        -> story(switch_background_image="bg_image.png")
 
-Design:
-    - revert: story() is a function, but should be heavily overloaded, so it gets 
-used for any kind of interacion with the setting. -> story(background="...", 
-show_image="...", clear_images=True, background_musi="...", play_sound="...", ...)
 
-The code for the TextRPG can be found at U{http://freehg.org/ArneBab/textrpg}
+Basic design principles for the scripting language: 
+    
+    - The action is character centered wherever possible and useful. 
+       -> char.say(text) instead of dialog(char, text)
+    
+    - Anything which affects only one character or any interaction between only a few characters which is initiated by one of them gets called from the character via char.action(). 
+       -> char.compete_skill(char2, skill_name) instead of competition_skill(char1, char2, skill_name)
+    
+    - Anything which affects the whole scene, or a whole group of not necessarily interacting characters gets called as basic function via action() or as class in its own right via class.action(). 
+       -> save([char1, char2]) instead of char1.save() char2.save()
+    
+    - The seperate class way should only be chosen, if the class can feel like a character in its own right and needs seperate states which may or may not be persistent over subsequent runs. 
+       -> For example AI.choose_the_way(players_answer) or music.action()
+    
+    - Data should be stored inside the chars wherever possible. If a script gets started with the same character again, the situation should resemble the previous one as much as possible, except where dictated otherwise by the story. 
+       -> char.save() instead of 'on quit' store_char_data(char) + 'on start' load_char_data(char)
+    
+    - Actions should be written as verb_noun or simply verb. 
+       -> char.say() and char.compete_skill() instead of char.text() and char.skill_compete()
+
+The code for the TextRPG can be found at U{http://dreehg.org/ArneBab/textrpg}
 
 """
 
 from anyrpg import __copyright__, __url__, __author__
 
+__copyright__ = """ 
+  rpg-1d6 - A general roleplaying backend. 
+  -> http://rpg-1d6.sf.net
+----------------------------------------------------------------- 
+© Copyright by Arne Babenhauserheide, 2008  (arne_bab@web.de) 
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+  MA 02110-1301 USA
+
+""" 
 __version__   = '0.3' 
+__author__    = 'Arne Babenhauserheide' 
+# __date__      = '7th March 2007' 
+__url__       = 'http://rpg-1d6.sf.net' 
+
 
 print "...Loading rpg library..."
 
 # AnyRPG function for localizing. 
 from anyrpg import _
 
+
 # Changing things. I want to display "..." in front of every blank story line. 
 
 class Story(any_story): 
 
 ### Test story lines ###
 
-
 def greet(char): 
     diag("Old man: Welcome traveller. You've come to the right place to learn about your heritage.")
     diag("Sadly you aren' well liked around here.")
+#!/usr/bin/env python
+#encoding: utf-8
+
+"""TextRPG Tutorial - Ein Leitfaden zur Nutzung des TextRPG.
+
+Lektionen: 
+ - Einleitung und Definition.
+ - Erzaehlen und ausprobieren. 
+ - Nutzer fragen und Geschichten weitergeben. 
+ - Charaktere erzeugen und sprechen lassen. 
+ - Proben und Wettkaempfe. 
+ - Charaktere laden und speichern.
+ - Kaempfe und Weiterentwicklung von Charakteren.
+ - Nichtlineare Geschichten und die Moeglichkeiten von Python. 
+ - Erweiterungen nutzen und selbst entwickeln.
+"""
+
+# First make sure the user has at least Python 2.5
+from sys import version_info
+if version_info < (2,5): 
+    print "TextRPG braucht mindestens Python Version 2.5."
+    print "Sie finden aktuelle Python Version auf "
+    print "- http://python.org "
+    exit()
+elif version_info >= (3,0): 
+    print "TextRPG wurde noch nicht auf Python Version 3 oder hoeher aktualisiert."
+    print "Bitte geben Sie uns die noetige Zeit, oder tragen sie zum Portieren bei."
+    print "- http://rpg-1d6.sf.net"
+    exit()
+
+from textrpg import story
+
+# Idee: Den Nutzer die Möglichkeiten gleich testen lassen. 
+from subprocess import call 
+
+story("""Willkommen im Interaktiven TextRPG Tutorial!
+
+Dieser Leitfaden wird Ihnen Schritt fuer Schritt die Moeglichkeiten des TextRPG 
+nahebringen und es Ihnen so ermoeglichen auf einfache Art eigene TextRPGs zu 
+schreiben. 
+
+Erstmal zur Definition: Ein TextRPG ist eine interaktive Geschichte, in die ihre 
+Nutzer eintauchen und ihren Ausgang beeinflussen koennen. 
+
+Auch wenn es mit komplexeren Skripten wohl moeglich waere, mit dem TextRPG ein 
+MMORPG zu implementieren, ist das nicht seine grundlegende Zielsetzung. 
+
+Stattdessen definiert es eine einfache Skriptumgebung, mit der der Code einer 
+interaktiven Geschichte sehr aehnlich aussieht wie ein Skript fuer ein 
+Theatertueck, Sie gleichzeitig aber auf die gesamte Macht von Python 
+zurueckgreifen koennen, mit dem Gruppen wie Google und die NASA vollwertige 
+Programme schreiben.
+
+Obwohl diese erste Version rein textbasiert ist, sind die Skripte auf eine Art 
+geschrieben, die eine spaetere Uebertragung in graphische Oberflaechen einfach 
+macht, so dass in den Skripten nur eingefuegt werden muss, welche Oberflaehe sie 
+nutzen sollen. Das gleiche gilt fuer sonstige Erweiterungen. 
+
+Fuer Charakterinteraktionen gibt sie Ihnen ausserdem eine vollstaendige RPG 
+Bibliothek, die das Ein Wuerfel System, ein universelles und frei lizensiertes 
+Rollenspielsystem, implementert. 
+
+Da das TextRPG in Python geschrieben wurde, funktioniert es direkt auf den 
+verschiedensten Plattformen, GNU/Linux, MacOSX und Windows eingeschlossen. 
+
+Dieser Leitfaaden ist uebrigens auch als TextRPG realisiert. 
+
+Nun aber genug der Vorrede. Gehen wir zur ersten Lektion. 
+""")
+
+story("""Lektion 1: Erzaehlen und direktes Ausprobieren des Gelernten.
+
+Um Ihnen die Eingaenglichkeit der Skriptsprache zu zeigen, moechte ich Ihnen vor 
+jeglichem Anderen zeigen, wie sie einen Text anzeigen koennen.
+
+Fuer einfache, zeilenweise angezeigte Texte koennen sie die 
+Funktion story('''text''') nutzen. 
+
+Ein Beispiel: Nehmen wir an, sie wollten ein Gedicht wie das folgende Zeilenweise 
+anzeigen: 
+
+Traeume in Texten
+Welten in Traeumen
+Menschen in Welten
+In eigenem Traum. 
+
+Sie schaffen sich eigene Texte. 
+
+Um dieses Gedicht in einem TextRPG anzuzeigen nutzen sie die story() Funktion: 
+
+story('''Traeume in Texten
+Welten im Traeumen
+Menschen in Welten
+In eigenem Traum
+
+Sie schaffen sich eigene Texte.''')
+
+Wie das funktioniert, koennen sie gleich direkt ausprobieren. 
+
+Sobald diese Lektion abgeschlossen ist, wird sich direkt im Text der Python 
+Interpreter oeffnen. 
+Auch wenn der Name etwas kompliziert klingt, ist das für was Sie ihn nutzen können extrem einfach: 
+
+Sie koennen Code eingeben und sehen sofort was er bewirkt.
+
+Dass sie im Intrepreter sind, erkennen sie (unter anderem) daran, dass die 
+Textzeile mit '>>> ' anfaengt. 
+
+Wenn sie code schreiben, der sich ueber mehrere Zeilen erstreckt (wie sie es z.B. 
+bei story() gesehen haben), aendert sich der Zeilenanfang in '... '. 
+
+Um den Interpreter wieder zu verlassen und mit dem Tutorial fortzufahren, druecken 
+sie einfach strg-d, d.h. sie druecken und halten die strg taste und druecken dann 
+die Taste d. 
+
+Wenn sich nun gleich der Intrepreter oeffnet, geben sie, um Ihre TextRPG Kenntnisse zu testen 
+als erstes das folgende ein (ohne '>>> '): 
+>>> from textrpg import *
+
+Damit koennen sie dann die Funktionen des TextRPG nutzen, z.B. story(). 
+
+Als naechsten Schritt rufen sie wie bereits beschrieben die Funktion story() auf: 
+
+story('''Traeume in Texten, 
+Welten in Traeumen
+Menschen in Welten
+In eigenem Traum. 
+
+Sie schaffen sich eigene Texte.
+''')
+
+Als Abschluss, verlassen sie den Python Intrepreter mit strg-d.
+
+Wir wechseln nun in den Python Intrepreter. """)
+
+call("python")
+
+story("""Lektion 2: Dem Nutzer Fragen stellen und Geschichten weitergeben.
+
+In Arbeit.
+""")
+