--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Structure of a client/server game, based on turns, events, orders and rules
+module framework is serialize
+
+import geometry
+import realtime
+
+# Main game object containing the world, players and tanks
+#
+# The game object is shared by both the client and the server.
+# So a method using the game object as visitor is to be executed client-side.
+class TGame
+
+ # `Story`, or rule book, with all the stats for this game
+ var story = new Story
+
+ # `Clock` timing the elapsed time between turns
+ private var clock = new Clock is noserialize
+
+ # Tick count of the last turn (The first turn as a tick of 0)
+ var tick: Int = -1
+
+ # Execute the next turn and return it as a `TTurn`
+ #
+ # This is to be executed server-side only.
+ fun do_turn: TTurn
+ do
+ var dt = clock.lapse
+ tick += 1
+
+ var turn = new TTurn(self, tick, dt.to_f, dt.millisec)
+ return turn
+ end
+
+ # Apply `turn` locally by updating `tick` and applying all events
+ #
+ # This is to be executed client-side only.
+ fun apply_turn(turn: TTurn)
+ do
+ tick = turn.tick
+ for event in turn.events do event.apply self
+ end
+end
+
+# A single turn of a `TGame`
+#
+# The turn object is created and populated by the server (using `TGame::do_turn`).
+# It is transmitted to the client but it cannot modify it.
+# So methods using the turn object as visitor are to be executed server-side.
+class TTurn
+
+ # `TGame` of which `self` is part of
+ var game: TGame
+
+ # Tick of this turn
+ var tick: Int
+
+ # Elapsed seconds since previous turn (as a `Float`)
+ var dts: Float
+
+ # Elapsed milliseconds since previous turn (as a `Int`)
+ var dt: Int
+
+ # `TEvent` that happened during this turn
+ #
+ # Events are added using `add`.
+ # This information is used to apply the turn client-side to update its game object.
+ # It is also used by effects on the UI and could be used by an AI.
+ var events: SequenceRead[TEvent] = new Array[TEvent]
+
+ # Add an `event` to `events` and apply it right away server-side
+ fun add(event: TEvent)
+ do
+ event.apply game
+ events.as(Array[TEvent]).add event
+ end
+end
+
+# Game event sent from the server to the client
+class TEvent
+
+ # Executed client-side to apply this event on the `game`
+ fun apply(game: TGame) do end
+end
+
+# An order sent from the client to the server
+class TOrder
+
+ # Apply order server-side on `turn`, usually spawns `GameEvent`
+ fun apply(turn: TTurn) do end
+end
+
+# An entity acting on each turn
+class TTurnable
+
+ # Act on `turn`
+ fun do_turn(turn: TTurn) do end
+end
+
+# A collection of `Rule` guiding the game
+#
+# Changing the story could (in theory) be enough to completely change the context of the game.
+# In _Tinks!_ however, we use this class lightly and fill it with static content.
+class Story
+end
+
+# Metadata of in game `Ruled` entities, keep their stats and assets in a single place
+class Rule
+
+ # `Story` to which `self` belongs
+ var story: Story
+end
+
+# A game entity with metadata in its `rule`
+class Ruled
+
+ # Kind of `Rule` for `rule`
+ type R: Rule
+
+ # Metadata of this entity
+ var rule: R
+end
+
+# Should the game show more information for debugging?
+fun debug: Bool do return false
nitlanguage / nit.git / blobdiff