Thema: Covella - Fantasy-Kalender - DSL für beliebige Systeme von Zeitmessung

[1of3]

Eine Herausforderung hierbei wird es sein, unterschiedliche (fiktive) Kalender zu unterstützen.

Das scheint mir jetzt gerade das einfachste an dem Unterfangen. Wenn du willst, helf ich da gern. Mit welcher Sprache willst du das genau machen? Ich vermute Java? (Mein Favorit ist Scala.)

[Talwyn]

Für Android habe ich Scala noch nicht verwendet. Was ich mit Herausforderung bei den Kalendern meinte ist: Es sollte für Nicht-Programmierer möglich sein, auf relativ einfache Weise den Kalender ihrer Spielwelt so zu beschreiben, dass die App damit arbeiten kann.

[1of3]

Verstehe. Dann schauen wir doch mal.

Ein Kalendersystem ist ein Objekt, das eine Liste von Tages-Zyklen enthält. Bei uns ist das der Jahreszyklus und der Wochenzyklus. (Wir können auch weitere Zyklen wie etwa den Mondzyklus oder die Jahreszeiten hinzunehmen.)

Code: [Auswählen]

case class CalendarSystem (cycle : Days*)
Wir brauchen also Klassen für Mengen von Tagen. Diese Klassen sollten komponierbar sein und wieder Tage ergeben. Wir möchten zudem sicher wissen, wie viele Tage eine Instanz von Days enthält.

Code: [Auswählen]

abstract class Days {
def number : Int}

case class SimpleDays(number: Int) extends Days{
def + (that: SimpleDays) = CompoundDays(List(this, that))
def + (those: CompoundDays) = CompoundDays(this + those.comps)
}

case class CompoundDays (comps : Seq[Days]) extends Days {
def number = comps map (_ number) sum
def + (that: SimpleDays) = CompoundDays(this.comps :+ that)
def + (those: CompoundDays) = CompoundDays(this.comps ++ those.comps)
}

Um das ganze brauchbar zu machen, müssen wir Tage mit einem Bezeichner ausstatten können, also z.B. Woche, Monat, Jahr. Zudem haben einige Days-Objekte Eigennamen, wie Mittwoch oder Januar. Um das ganze anschaulich zu machen, fügen wir passend benannte Setter hinzu.

Unsere abstrakte Klasse sieht nun so aus.

Code: [Auswählen]

abstract class Days {
def number : Int
var designation: Option[String] = None
var name: Option[String] = None
def as(des : String) designation = Some(des)
def named(nam : String) name = Some(nam)
}

Für größere Konvenienz wählen wir zwei Factory-Funktionen für Tages-Objekte.

Code: [Auswählen]

object Days{
def apply(number : Int) = SimpleDays(number)
def apply(names: String*) = names map (SimpleDays(1) named _) foldLeft(Days.empty,_+_)
}
Wir können einen Kalender nun so definieren.

Code: [Auswählen]

val woche = Days("Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag","Sonntag") as "Woche"

val januar = Days 31 as "Monat" named "Januar"
val februar = Days 28 as "Monat" named "Februar"
val schaltFebruar = Days 29 as "Monat" named "Februar"
val maerz = Days 31 as "Monat" named "März"
val april = Days 30 as "Monat" named "April"
val mai = Days 31 as "Monat" named "Mai"
val juni = Days 30 as "Monat" named "Juni"
val juli = Days 31 as "Monat" named "Juli"
val august = Days 31 as "Monat" named "August"
val september = Days 30 as "Monat" named "September"
val oktober = Days 31 as "Monat" named "Oktober"
val november = Days 30 as "Monat" named "November"
val dezember = Days 31 as "Monat" named "Dezember"

val jahr = (januar + februar + maerz + april + mai + juni + juli + august + september + oktober + november + dezember) as "Jahr"

val schaltjahr =  (januar + schaltFebruar+ maerz + april + mai + juni + juli + august + september + oktober + november + dezember) as "Jahr"

julianisch = CalendarSystem (woche, jahr + jahr + jahr + schaltjahr)
Damit das System gültig ist, liefert der Konstruktor eine Fehlermeldung, wenn…

• Bezeichner in unterschiedlichen Zykeln auftreten. Wenn der erste Zyklus etwas namens "Woche" enthält, darf der zweite Zyklus das nicht.
• Wenn CompoundDays den selben Bezeichner tragen, wie eines ihrer Elemente. Ein "Monat" darf also z.B. keine Monate enthalten.

Mit einem Kalendersystem können wir aber noch nicht arbeiten. Wir brauchen mindestens ein Start-Datum, dass die Zykel synkronisiert. Wir müssen also für mindestens ein Jahr und einen Tag im Jahr wissen, welcher Wochentag das ist.

Wir brauchen also ein weiteres Objekt, nennen wir es Era. Nutzerfreundlich benutzen wir eine Factory-Funktion auf unserem CalendarSystem. Nennen wir sie startWith. Also in unserem Fall z.B.

Code: [Auswählen]

val julianischerKalender = julianisch startWith ("Samstag", 1)
Ich nehme für die Funktion zunächst passende Überladungen an.

Nota bene: Der erste Januar im Jahre 1 war ein Samstag, jedenfalls wenn wir das ausrechnen. Die Planetenwoche war noch nicht sehr in Mode und die Zählung ab Christi Geburt noch nicht erfunden.

Es sollte vielleicht noch passende Funktionen geben, um ein Days-Objekt zu wiederholen. Ich hätte keine Lust den gregorianischen Kalender auf diese Weise zu schreiben. Natürlich kommen realiter Kalenderwechsel und Reformen vor. Davon würde ich absehen. That way lies madness.

Womöglich ist es aber gewünscht auch mit dem Jahr 1970 starten zu können, als mit einem Tag aus der ersten Jahresrunde. Da bräuchte es dann eine erweiterte startWith-Funktion. Das ließe sich vielleicht auch mit benannten Jahren, etwa im Stil vom Year of Blue Fire der Forgotten Realms oder den Konsulzählungen der Römer kombinieren.

Letztlich braucht es eine Klasse für bestimmte Daten mit passenden Gettern und Methoden wie next und previous.

[Antariuk]

Ich verstehe von 1of3s Beitrag leider kaum etwas da ich 0,0 Programmierkenntnisse habe, aber wenn es um Kalendaerfunktionalitäten geht finde ich das Eberron Calendar Tool von Wizards immer eine coole Vorlage um zu sehen, was man theoretisch machen könnte. Das Feature der Existenzebenen mit den waning/waxing/coterminous Zuständen könnten in anderen Settings auch Monde sein, wenn man das eine offen eintragbare Funktion macht.

[firstdeathmaker]

Das Problem mit den Kalendern sehe ich auch eher darin, dass sie zwar in unserer realen Welt noch eingermaßen gut funktionieren (sieht man mal von den ganzen Ausnahmen ab), aber eben nur bedingt flexibel für sämtliche Fantasy-Settings funktionieren. Und ich will ein Fantasysetting vielleicht nicht nur nach äquitemporaler Zeit gelten lassen.

Ein wirklich umfassendes Kalendersystem für Fantasy, das man konfigurieren kann, sollte folgende Funktionen besitzen (nicht zwingend, aber um so mehr nach unten hin, um so flexibler wäre es):

Normaler heutiger benutzter Kalender
Kalender, die verschiedene Zeitalter und darin unterschiedliche Zeitrechnungen berücksichtigen. z.B. im ersten Zeitalter 8-Tage Wochen, 50-70 Tage Monate), im zweiten Zeitalter 5-Tage Wochen etc.
Lunare römische Kalender
Maya-Kalender
Weltenübergreifender Kalender (wie im oben geposteten Tool https://www.wizards.com/dnd/ec/index.htm) mit unterschiedlich schnell vergehender Zeit
Nichtlinearer Zeitfluss Kalender (für Zeitreisenszenarios mit alternativen Realitäten)
Nichtkonstanter Zeitfluss (Relativistischer Kalender für so etwas wie im Film "Interstellar")

Und da wird es halt extrem frickelig. Das Thema "Kalender" lasse ich bei meinem Tool bewusst aus. Dafür bräuchte man auch etwas mehr Dynamik als man mit HTML ohne weiteres realisieren kann.

[Talwyn]

Sehr fleißig 1of3, das sieht schonmal super aus . Ich würde es auch in einem vernünftigen Rahmen halten und Dinge wie Zeitreisen, Kalenderwechsel usw. ausschließen. Was man allerdings bräuchte, wäre eine Erweiterung, um Dinge wie Schaltjahre und Feiertage abbilden zu können am Beispiel des Calendar of Harptos (Forgotten Realms):

Code: [Auswählen]

val tenday = Days 10 as "Tenday"

val hammer = Days 30 as "month" named "Hammer" aka "Deepwinter"
val midwinter = Days 1 as "holiday" named "Midwinter"
val alturiak = Days 30 as "month" named "Alturiak" aka "The Claw of Winter" or "The Claws of the Cold"
val ches = Days 30 as "month" named "Ches" aka "The Claw of Sunsets" with event "Spring Equinox" on 19
val tarsakh = Days 30 as "month" named "Tarsakh" aka "The Claw of Storms"
val greengrass = Days 1 as "holiday" named "Greengrass"
val mirtul = Days 30 as "month" named "Mirtul" aka "The Melting"
val kythorn = Days 30 as "month" named "Kythorn" aka "The Time of Flowers" with event "Summer Solstice" on 20
val flamerule = Days 30 as "month" named "Flamerule" aka "Summertide"
val midsummer = Days 1 as "holiday" named "Midsummer"
val shieldmeet = Days 1 as "holiday" named "Shieldmeet" occurring every 4 years startingAt 0
val eleasis = Days 30 as "month" named "Eleasis" aka "Highsun"
val eleint = Days 30 as "month" named "Eleint" aka "The Fading" with event "Autumn Equinox" on 21
val highharvesttide = Days 1 as "holiday" named "Highharvestide"
val marpenoth = Days 30 as "month" named "Marpenoth" aka "Leafall"
val uktar = Days 30 as "month" named "Uktar" aka "The Rotting"
val feastOfTheMoon = Days 1 as "holiday" named "Feast of the Moon"
val Nightal = Days 30 as "month" named "Nightal" aka "The Drawing Down" with event "Winter Solstice" on 20

val calendarOfHarptos = harptos // an dieser Stelle äußerst einfach, weil im Kalender des Harptos jedes Jahr immer mit einem frischen Zehntag beginnt.

Dementsprechend müsste man die Klassen erweitern, um diese Konstrukte abbilden zu können. Mal sehen, evtl. komme ich am Wochenende dazu was zu machen.

[1of3]

named "Alturiak" aka "The Claw of Winter"

Vielleicht einfacher: named ("Alturiak", "The Claw of Winter") Dann einfach ne Seq von Namen. Man kann natürlich aka als Alias verwenden, um Namen anzufügen.

Wie man schon jetzt Schaltjahre machen kann, hab ich ja beim julianischen Kalender gezeigt: Einfach verschiedene Jahre anlegen und addieren.

Eine Auszeichnung für besondere Ereignisse und Feiertage ist eine gute Idee. Schön wäre, wenn man relativ leicht verschiedene Zyklen schneiden kann, also im Stile von: Wenn ein Freitag der 13. eines Monats ist. Das ist bei ganz vielen Kulturen eine wichtige Methode für Tagesauszeichnungen.

Ich hab noch ein bisschen experimentiert. Ich würde noch erzwingen, dass Elemente eine Designation haben müssen, bevor man sie komponieren kann, also alles, was man addieren will muss vorher ein "as" bekommen. Dazu also gemäß Immutable Builder Pattern die Klasse ändern. Ich hab das noch mal gemacht und ein paar Bugs entfernt.

(Klicke zum Anzeigen/Verstecken)

Code: [Auswählen]

abstract class Days {
  def number : Int
  var name: Option[String] = None
  def named(nam : String) = name = Some(nam)

  def as(designation : String) = QualifiedDays(this,designation)
}

case class QualifiedDays(days: Days, designation: String) extends Days{
  def + (that : QualifiedDays) = CompoundDays(ArrayBuffer(this,that))

  def number = days.number
    override def named(nam : String) = days.name = Some(nam)

  def repeatWithNames(names : Seq[String]) : CompoundDays = {
    val output = for (i <- 0 to names.length) yield QualifiedDays(days, designation)
    for (i <- 0 to names.length) output(i) named names(i)
    CompoundDays(ArrayBuffer(output).flatten)
  }
}

case class CompoundDays (comps : ArrayBuffer[QualifiedDays]) extends Days {
  def number = comps map (_ number) sum

  def + (that: QualifiedDays) = comps += that

  override def as(des: String): QualifiedDays = if ( comps.map(_.designation).contains(des) )
    throw new IllegalArgumentException("Designator '" + des + "' of CompoundDays is the same as designator of component.")
            else super.as(des)
}

[firstdeathmaker]

Wie sähe das Kalendersystem eigentlich bei parallel laufenden Kalendern aus? Also z.B. wenn ich einen chinesischen und einen westlichen habe und ein Datum umrechnen möchte?

Wenn ich richtig gesehen hab, dann könnte man damit ja sogar Zeitalter realisieren und diese aneinander hängen. Aber was ist mit unterschiedlich schnell vergehenden Tagen? Z.b. Marstage und Erdtage?

[1of3]

Ich hab für das Paket "Tag" als Referenzgröße gewählt. Unterschiedliche Tageslängen von Planeten sind so schwierig. Mehrere Kalender in ein System zu packen ist aber möglich.

Generell bräuchte es auf einem Datum eine Methode

Code: [Auswählen]

def get(designator: String) = ???
Da kann man also problemlos get("Westliches Jahr") und get("Chinesisches Jahr"). Ich hadere momentan ein bisschen mit der Implementierung, aber das ist der Plan.


Edit: Ich muss den ersten Satz nach etwas nachdenken übrigens korrigieren. Nur weil ich die Objekte "Days" genannt habe und als "Standard-Tick" einen Tag im Kopf hatte, heißt das natürlich nicht, dass man nicht genauso gut von "Minutes" oder "Nanoseconds" ausgehen könnte. Ggf. möchte man dann ein Type-Alias ("type Minutes = Days") schreiben oder auch zwei, damit die Sachen nicht so merkwürdig heißen, aber die Funktionalität bleibt ja die selbe.


EditEdit: So. Getter funktioniert eingschränkt.
- Nicht bei negativen Daten oder Datum 0. Hier müsste man die Zyklen rückwärts durchlaufen.
- Nur beim primären Zyklus. Synchronisieren mit weiteren Zyklen geht noch nicht.
- Die Jahreszahl wird noch nicht angezeigt.

Hier einmal der vollständige Code bis jetzt.

(Klicke zum Anzeigen/Verstecken)

Code: [Auswählen]

import scala.collection.mutable.ArrayBuffer


case class Era (calendar: Calendar, startingCount: Int) {
  val primaryCycle = calendar.primaryCycle

  val primaryCounter : String = calendar.primaryCounter.
          getOrElse(if (primaryCycle.isInstanceOf[QualifiedDays]) primaryCycle.asInstanceOf[QualifiedDays].designation
                    else {
                     val designationSet = primaryCycle.asInstanceOf[CompoundDays].children.map(_.designation).toSet
                     if (designationSet.size == 1) designationSet.head
                     else throw new IllegalArgumentException("Could not determine primary counter for Era.")
                    } )


  var synchronizedCycles: Set[Days] = Set() // Lieber Kalender? Oder beides? Wie kommt die Synchronisation da rein?

  def synchronizeAt (days: Days, at: Int) = ???

  def synchronize (days: Days) = SynchronisationTemplate(this,days)

  def apply(i: BigInt) = {
    val remainder = i % primaryCycle.number
    if (primaryCycle.isInstanceOf[QualifiedDays]) primaryCycle.asInstanceOf[QualifiedDays](remainder)
    else (primaryCycle as "")(remainder)
  }

 // def round = (synchronizedCycles + primaryCycle) map(_ number) foldLeft(1,lcm (_ ,_))
 // private def gcd(a: Int, b: Int): Int = if (b == 0) a.abs else gcd(b, a % b)
 // private def lcm(a: Int, b: Int) = (a * b).abs / gcd(a, b)

}


case class SynchronisationTemplate(era: Era, days: Days){
  def at(int: Int) = era.synchronizeAt(days,int)

}

case class Calendar (primaryCycle: Days) {

var primaryCounter : Option[String] = None
def countIn(designation: String) = primaryCounter = Some(designation)

def startIn(startingCount: Int) = Era(this,startingCount)



}





case class Datum(day: BigInt)(implicit era: Era){

def get(designator: String): Option[(Days,Option[Int])] =
          try { Some(era(day).map {case (string,days,optionInt ) => string -> (days,optionInt) }.toMap.apply(designator)) }
          catch { case e: Exception => None }


def indexOf (designator: String) = IndexTemplate(designator,this)

}

case class IndexTemplate(designator: String, datum: Datum){

  def in(designator: String) : Int = ???

}


case class EventTemplate(eventName: String, in: Days){
  def on (i: Int) = if (i <= in.number && i>=0) in.events = in.events ++ Seq(eventName -> i)
                    else throw new IllegalArgumentException("Attempted to add event '" +
                              eventName + "' on day'" + i+ "of " + in.number + " days." )

}


abstract class Days {
  def number : Int
  var name: Option[String] = None
  def named(nam : String) :Days = {name = Some(nam); this}
  var events : Seq[(String,Int)] = Seq()
  def hasChildren : Boolean

  def event (eventName: String) = EventTemplate(eventName, this)
  def as(designation : String) = QualifiedDays(this,designation)

  override def toString: String = name.getOrElse("") + "(" + number + " days)"

}


case class QualifiedDays(days: Days, designation: String) extends Days{
  def + (that : QualifiedDays) = CompoundDays(ArrayBuffer(this,that))

  def number = days.number
    override def named(nam : String) = {days.name = Some(nam); this}

  def repeatWithNames(names : Seq[String]) : CompoundDays = {
    val output = for (i <- 0 to names.length) yield QualifiedDays(days, designation)
    for (i <- 0 to names.length) output(i) named names(i)
    CompoundDays(ArrayBuffer(output).flatten)
  }

  override def hasChildren: Boolean = days.hasChildren

  override def toString: String = designation + ": " + days

  def apply(i : BigInt) : Seq[(String ,Days,Option[Int])] = if (i > number || i <1)
            throw  new IllegalArgumentException("Tried to retrieve '" + i
              + "' from a set of '" + number + "' units designated as " + designation + "." )
    else if (!hasChildren) Seq( (designation, days, None ) )
    else Seq( (designation, days, None ) ) ++ followPath(days.asInstanceOf[CompoundDays],i)


    def followPath(compoundDays : CompoundDays, newI : BigInt) : Seq[(String ,Days,Option[Int])] = {
       val (qdays, index, remaining) =compoundDays.getChildfor(newI)
       if (!qdays.days.hasChildren) Seq((qdays.designation, qdays.days, Some(index)))
       else Seq((qdays.designation, qdays.days, Some(index))) ++ followPath(qdays.days.asInstanceOf[CompoundDays],remaining)
    }

}



case class CompoundDays (children : ArrayBuffer[QualifiedDays]) extends Days {
  def number = children map (_ number) sum

  override def hasChildren: Boolean = if (children.isEmpty) false else true

  def +(that: QualifiedDays) = {children += that; this}

  override def as(des: String): QualifiedDays = if (children.map(_.designation).contains(des))
    throw new IllegalArgumentException("Designator '" + des + "' of CompoundDays is the same as designator of component.")
  else super.as(des)



  def getChildfor(i: BigInt): (QualifiedDays, Int, BigInt) = {
    def selectChild(newI: BigInt, offset: Int): (QualifiedDays, Int, BigInt) = {
      if (newI <= children(offset).number) (children(offset),offset,newI)
      else selectChild(newI-children(offset).number,offset+1)
    }
    if (!hasChildren) throw new IllegalStateException("Compound has no Children") else selectChild(i, 0)
  }

}


  case class SimpleDays(number: Int) extends Days{
    override val hasChildren: Boolean = false


  }

  object Days{
    def apply(number : Int) = SimpleDays(number)
    def apply(names: String*) = SimpleDays(1) as "" repeatWithNames names
  }


object Main extends App {

  val januar = Days(31) as "Monat"  named "Januar"
  val februar = Days(28) as "Monat" named "Februar"
  val schaltFebruar = Days(29) as "Monat" named "Februar"
  val maerz = Days(31) as "Monat" named "März"
  val april = Days(30) as "Monat" named "April"
  val mai = Days(31) as "Monat" named "Mai"
  val juni = Days(30) as "Monat" named "Juni"
  val juli = Days(31) as "Monat" named "Juli"
  val august = Days(31) as "Monat" named "August"
  val september = Days(30) as "Monat" named "September"
  val oktober = Days(31) as "Monat" named "Oktober"
  val november = Days(30) as "Monat" named "November"
  val dezember = Days(31) as "Monat" named "Dezember"

   val jahr = (januar + februar  + maerz + april + mai + juni + juli + august + september + oktober + november + dezember)  as "Jahr"
  val schaltjahr =  (januar + schaltFebruar+ maerz + april + mai + juni + juli + august + september + oktober + november + dezember) as "Jahr"

  implicit val julianisch = Calendar(jahr+jahr+jahr+schaltjahr) startIn(1970)

  val testdatum = Datum(361)

  println((testdatum get "Monat") + "\n" +  (testdatum get "blörz") )

}

[1of3]

So. Einige weitere Gedanken. firstdeathmakers Hinweis, auch kleinere Zeiteinheiten zu unterstützen ist gut. Ich hab die Klassen ein wenig umbenannt. Statt "Days" heißt es "Units" und die kleinste Einheit ist "Tick".

Spätestens damit ergeben sich für die Abwicklung verschiedene Konsequenzen. Die Builder-Objekte für die DSL sind zwar sehr nett, aber in der Verwendung sind sie enorm unhandlich. Zudem instanziieren wir sehr viele davon, was nicht günstig ist. Im Betrieb braucht es also eine einfachere Datenstruktur.

In der Vewendung braucht es etwa folgende Fragestellungen:

- Liebe $Zeiteinheit, die wievielte bist du in $AndererZeiteinheit?
- Liebes $Datum, was ist deine Standarddarstellung?
- Liebes $Datum, in welcher Ausgabe von $Zeiteinheit liegst du?
- Liebes $Zeitintervall, ich hätte gern ein Ereignis auf dir.
- Liebes $Datum, welche Ereignisse gibts bei dir?⁽¹⁾

Ich hab mir mal ein paar Implementierungen angeguckt und die meisten schummeln. Einfach, weil sie z.B. wissen, dass dieses Ding namens November, der elfte Monat in dieser Sache namens Jahr ist. Die rechnen nicht, die lesen ab.

Was kann man machen:

Eine Era merkt sich zunächst mal nicht die Hierarchie der Builder-Objekte, sondern eine Klassifikation von Designationen, also Zeiteinheiten.

Besonders angenehm sind diejenigen, die sich uniform durchziehen. Die also erstens überall verfügbar und zweitens immer gleich lang sind. Bei uns z.B. Tage, Stunden und alles, was kürzer ist. Bei denen müssen wir nur wissen, wie lang sie sind.

Nicht ganz so hübsch, diejenigen, die zwar überall vorhanden, aber nicht immer gleich lang sind, z.B. Jahre und Monate.

Ganz hässlich sind diejenigen, die sporadisch vorkommen, also z.B. in Talwyns Harptos-Kalender die Monate und besonderen Feiertage, die sich abwechseln.

Bei jeder Designation sollte zudem stehen, worin sie standardmäßig gezählt wird. Wir zählen also Stunden für gewöhnlich in Bezug auf den laufenden Tag. Wir können uns natürlich, fragen wie viele Stunden seit Beginn des siderischen Monats, aber das ist nicht häufigste Anfrage. Also wenn ich ein Ding frage: "Das wie vielte bist du?", sollte es wissen, worin es standardmäßig gezählt wird.

Was alternative Namen angeht, wie Talwyn vorgeschlagen hat, würde ich eine Zuordnung (Map/Dictionary) benutzen, also z.B.

val alturiak = Days 30 as "month" named "Alturiak" aka "poetic"->"The Claw of Winter" aka "poetic2"->"The Claws of the Cold"

Entsprechend kann man dann beliebig viele Varianten jeweils mit Bezeichner anfügen. Wir würden wahrscheinlich sowas wie
"short"->"Jan" für Januar wollen.

Für Ereignisse schwebt mir folgende Syntax vor:

Code: [Auswählen]

event $eventName at $datum1 till $datum2 per $Designation given $condition §direction
Je nachdem, auf welchem Objekt man "event" aufruft können z.B. Anfang und Ende auch schon gesetzt sein. Direction gibts in drei Varianten: forewards, backwards und foreAndBack. Letzteres ist Standard, wenn es sich nicht um einmaliges Ereignis handelt.

[Talwyn]

Hab gerade leider keine Zeit, weil ich hier auf Arbeit blöderweise dafür bezahlt werde, unser Rechnungslegungssystem mit Salesforce zu integrieren, obwohl ich doch gerade viel lieber Rollenspielkalender programmieren würde Trotzdem sieht der Stand bisher schonmal gut aus - und: Siehste - ist nicht so trivial wie es zunächst aussieht, die Kalendersache.

Da ist hinsichtlich meiner App tatsächlich z.B. die UI-Komponente für die Karte das kleinere Problem, da gibt es nämlich schon eine sehr schöne OpenSource-Implementierung.

[Talwyn]

Aber nur so als Frage: Wollen wir ein Github-Projekt für die Kalender-Library starten? Das wäre für mich auch eine schöne Gelegenheit, endlich mal ernsthaft mit Scala zu arbeiten (bislang habe ich es nur punktuell dort eingesetzt, wo mir Java zu unhandlich geworden ist, z.B. für XML-Verarbeitung).

[1of3]

Sehr gern. Dann komm ich endlich mal dazu mit Github zu arbeiten.

Ich lad das heute Abend mal hoch.

[Talwyn]

Ich kann auch ein Repo mit einem Grundgerüst anlegen - Scala 2.11.8, sbt 0.13.12, Scalatest 2.11 3.0.0, MIT License?

Achso, und auch wichtig: Einen Namen braucht das Kind.

Wie wäre es mit libficcal (LIBrary for FICtional CALendars) oder kürzer ficcal oder fical oder Coolified "Fickle"? Oder ganz was anderes? Fantasy Calendar finde ich zu lang und auch nicht ganz passend.

[1of3]

Ja, mach mal gern.

Da ich deutscher Muttersprachler bin, löst "ficcal" bei mir keine besonders ehrfürchtige Reaktionen aus.
Wie wärs mit "sideral"? Es gibt ja lunare und solare und lunisolare Kalender und wir transzendieren das. Oder... "Covella" war die Göttin, welche der römische Priesterkönig am Ersten des Monats angerufen hat.

[Talwyn]

Covella klingt doch gut. Ich mache mal.

[Talwyn]

Done: https://github.com/sandboxly/covella

Wenn du mir noch deinen Github Usernamen sagst, kann ich dich als Colaborator hinzufügen.

Die Ordnerstruktur für die Sourcen und Resourcen konnte ich leider nicht anlegen, da man leere Ordner nicht in ein Git Repo committen kann.

Ich schlage aber die bekannte Struktur vor: src/main/scala, src/main/resources, src/test/scala, src/test/resources

Wenn ich heute Abend Zeit finde, Setze ich noch Travis und Codeclimate auf.

[1of3]

Jo. Das bin ich.

[Pyromancer]

Hm, ich hätte das Ganze von der astronomischen Seite aufgezogen. Solare und lunare Zyklen (vielleicht mit mehreren Monden), Jahreszeiten, Feiertage, Sonnwenden und Tagundnachtgleichen, Aussaat und Ernte, wiederkehrende Wetterphänomene, darum geht es doch eigentlich, nicht darum, Tage runterzuzählen.

[Talwyn]

Doch, genau darum geht es mir persönlich. Der Kalender dient dazu, den Fortschritt der Ingame Zeit zu tracken. Aber womit du definitiv Recht hast, ist die Aussage, dass der Kalender die Mondphasen ebenfalls unterstützen sollte: In meiner aktuellen D&D Kampagne hat sich ein SC mit Lykanthropie angesteckt, da ist der Use Case also bereits gegeben. Auch sollten mehrere Monde unterstützt werden, das gibt es ja auch in genügend RPG Settings. Sollte aber relativ einfach zu machen sein. Schreibe nur gerade vom Telefon, da ist die Eingabe von Code sehr mühsam.

Gesendet von meinem Nexus 5 mit Tapatalk

[Talwyn]

Was die Ereignisse angeht: Das wäre aus meiner Sicht nicht die Zuständigkeit einer allgemeinen Kalenderbibliothek, sondern eher die einer App(likation), die diese Bibliothek verwendet.

Gesendet von meinem Nexus 5 mit Tapatalk

[1of3]

Hm, ich hätte das Ganze von der astronomischen Seite aufgezogen. Solare und lunare Zyklen (vielleicht mit mehreren Monden), Jahreszeiten, Feiertage, Sonnwenden und Tagundnachtgleichen, Aussaat und Ernte, wiederkehrende Wetterphänomene, darum geht es doch eigentlich, nicht darum, Tage runterzuzählen.

Das ist dem Programm im Grunde Wumpe. Du kannst damit auch synodischen, siderischen und tropischen Monat für fünf Monde tracken, wenn das dein Ding ist. Oder das Erscheinen der Feenkönigen bei Hofe nebst dem Flackern des Artefakts von Schnackpuck und die Aussaatzeit von Yamok-Wurzeln. Muss ich nicht wissen, deshalb hab ich ja versucht eine recht eingängige Spezialsprache zu schreiben, damit man ohne viel Aufmachung ein System zur Zeitmessung schreiben kann.

[Antariuk]

Kleiner Vorweg-Wunsch für ein Feature: ausdruckbare Ergebnisse, bzw. Exportation des Kalenders als Grafikdatei. Wenn das möglich ist bei einem so offen gehaltenen Ansatz. Würde die Benutzbarkeit für mich quasi verdoppeln

[1of3]

Ich bin mir nicht ganz sicher, was du mit Grafik meinst. Ich kann einen Kalender als Tabelle darstellen. Beschreib mal bitte, was du dir vorstellst..

[Antariuk]

Ich bin mir nicht ganz sicher, was du mit Grafik meinst. Ich kann einen Kalender als Tabelle darstellen. Beschreib mal bitte, was du dir vorstellst..

Das man eine Übersicht des gebastelten Kalenders als JPG, BMP oder PNG exportieren kann um sie sich später auszudrucken, in Kampagnen-Handouts einzufügen oder in ein Wiki zu tun. So z.B.: