Ink & Paper Engine (Traveler's Tale ; Away Mission)
CarterG81 opened this issue · comments
Traveler's Tale (thus Paper Engine) DevLog can be found over at the Unity Forums.
Paper Engine is designed to allow game writers to create (nearly) their entire (more than Text) game without ever leaving Ink. The goal is to eventually deliver games of ever-increasing complexity without losing the casual-friendly focus on Writers being the main skill required to make awesome games.
Major features include
- v1.0; Hexagonal Map & Player Movement, and Entering Locations (ex. Dungeons, Cities, etc.) or other Hexagonal Maps (World Map, Region Map, City Map, etc.).
- v1.0; Polyhedral Dice System for Conflict Resolution (D2, D4, D6, D8, D10, D12. D20)
- v1.0; Combat Positioning System (Unique to Traveler's Tales)
- v1.0; Skill / Task Assignment System (Unique to Traveler's Tales)
- v1.0; Text Rendering - Narration Dialogue, Titles (Big font, centered, bold), Character Dialogue (Portraits, small GUI boxes appearing over or near character entities like chat Bubbles)
- v1.0; Static Image Rendering - Backgrounds, Characters, Props, Commands to manipulate Images, etc.
- v1.0; Audio Control - Play Music, Sound Effects, etc.
- v1.5; Special Effects - Particle Effects, small animations, etc.
- v1.5; Procedural HexMap Generation
- v1.5; Random Name Generation
- v2.0; Advanced A.I.
- v2.0; 2D Animation, Cinematic sequences, etc.
What is Paper Engine?
Ink & Paper Engine is a combination of Ink, JSON, C#, & Unity, which allows game developers to write their games entirely in INK, supplemented by gamer-friendly Game Tools made in Unity or JSON edited text.
The most important function of Paper are the Commands, written in Ink.
Story Text Story Text
>>Command(Parameters)
Character: Dialogue Text
and the "Game Modes" which are optional features which rely on Ink / JSON parsed by Unity.
An example of going from GAMEMODE(MAP) to GAMEMODE(SCENE)
Paper Engine is, in fact, the technology I will be developing for my team's games. So if our game has a feature, Paper Engine will have it too.
Since our games will be fully moddable (with all the tools, source, art, and Ink functions packaged with the games), anyone who owns our games will be able to make games with Paper Engine.
Why Paper engine?
Our games can be created in Paper Engine, one after the other.
Our team has worked on three unreleased games: Traveler's Tales, Away Mission, and Beyond the Forest. To be brief,
Traveler's Tale is our attempt at turning our favorite PnP moments into a semi-roguelike, semi-RPG game about Travel and More-Than-Violence conflict resolution. Inspired by books like The Hobbit and games like Curious Expedition, Neo Scavenger, and retro Tolkien game freeware.
Away Mission is our attempt at creating a game which puts the Player in the role of Captain of their very own Treky spaceship.
The design is best summed up as attempting to be a "Starflight-like StarTrek:TNG-like Captain Simulator with FTL inspired artstyle", obviously within our own unique IP of what we think a Treky future would actually be like (with a rainbow of uniform colors to show the great variety of Scientific fields of study)
Both of these games share a lot in common; especially Ink for their dynamic story content & our desire to allow them both to be heavily or entirely MODDABLE. Edit these games or create your own games or fan-fiction using the game logic or start from scratch with Paper Engine and all its features.
Who are you?
We are currently part time developers who have been working the past 8 years, trying to release our first game. Traveler's Tale is our mini-scope game, Away Mission (Paused) our more complex game, and Beyond the Forest (Paused) our biggest scope project. Away Mission was quickly prototyped, then put on hold to make a smaller scope game due to the complexity of its systems & our desire to make sure it is the best game it can be. Beyond the Forest has simpler systems (far less innovation or complexity), but ended up being a larger scope game which we devoted over 2000 hours into, creating a fully working multiplayer server and a lot of art & systems for our open world game.
We paused development of Beyond the Forest, despite having so much progress, because of Financial Reasons. Release was still 1-2 years away. Traveler's Tale is our 1-3 month attempt at creating a game which will allow us to become Full Time Developers. Our costs of living are quite low considering our team & skills, but without income we work at a snail's pace. We want this part time work to end so we can begin creating games significantly faster. Significantly.
So... should we take development of Paper Engine... Seriously?
Here is the Caveat: Our first priority is in developing our games. While Traveler's Tale will definitely include the first version of Paper Engine, with the game being fully moddable at or shortly after release, we cannot guarantee that Paper Engine 2.0 will be the best choice for Away Mission. That requires a discussion, engineering, and plans for a game we have on the backburner.
I'd love to release Paper Engine as an open source project, but for now we're planning on just bundling it (and likely as much of the source as possible) with the sale of our game Traveler's Tale. I'm not really sure we can survive if we don't sell Traveler's Tale as both a Game AND an Engine. I hate corporations, greed, and I love an open internet & open world, but we are just a small team of skilled developers who currently have very low income levels. I myself work full time as a mentor for underprivileged children and counselor's assistant, for the last 6 years.
Passionate, Experienced, and Devoted
However it is important to note that I personally have been working since 2009 to learn to make, and then actually create, games. This has been a non-stop, all-consuming passion of mine for the last >8 years. So this isn't a matter of "Will we Release these 3 games?" but a matter of "WHEN will we release these 3 games?" Our success with Traveler's Tales will decide the difference between these 3 games being released over the years or over decades. There is an enormous difference between being a part time hobbyist & full time developer.
CURRENT PROGRESS - COMMANDS LIST
GAMEPLAY
Game Modes
>>GAMEMODE:SCENE
Switch to SCENE Mode to show pictures, display sprites, tell story, and receive choice input.
>>GAMEMODE:MAP
Switch to MAP Mode to allow the Player to move around a Map.
SCENE MODE
BACKGROUND
>>SetBackgroundImage(ImageName)
Changes the Background to this Image.
SPRITES
>>CreateSprite(SceneID, ImageName, PositionX, PositionY, Flipped)
Reference sprite by its SceneID, for any future commands.
ImageName should include the filename without the extension (Bob.png would just be “Bob”)
Flipped is a bool, so “true” for flipped or “false” for not flipped. All characters should default facing Right ->
>>MoveSprite(SceneID, PositionX, PositionY)
>>MoveSprite(SceneID, PositionX, PositionY, Flipped)
Move a Sprite entity to a new position. Flipping is optional.
>>ChangeSprite(SceneID, ImageName)
Description
>>RemoveSprite(SceneID)
Destroy a sprite from the scene. All you need is its reference SceneID. You cannot recover a removed sprite.
STORY
>>RequireContinue
This requires the Player to use Continue Input to progress to the next line of INK.
You would want to use this if you have no story text between Commands, such as when changing images while wanting the player to use input so they see the sprites change at the player’s pace.
By default, PaperEngine automatically continues to the next line after a Command, will keep on parsing commands line after line, and will not stop until it finally receives Story Text (a line of Ink text that isn’t a >>COMMAND).
DIALOGUE / SPECIAL TEXT
Title>:DialogueText
This will render "DialogueText" as large font, bold, centered text.
Later versions may turn this into a function which also controls other options (Font Size, Font Color, etc.)
MAP MODE
MAPS
>>CreateMap(MapID, MapSizeX, MapSizeY)
Reference Map by its MapID, for any future commands.
Create a new Map of {MapSizeX} by {MapSizeY} size.
PROCEDURAL GENERATION
>>ReplaceAllTileType(MapID, TileToReplace, NewTileType)
(ex. ReplaceAllTileType(AdventureMap1, Forest, Ocean) will replace all the Forest tiles with Ocean tiles.)
>>AddNoiseI(MapID, TileType)
Adds a random tile of TileType to MapID map. This will only call the function once.
>>AddNoiseI(MapID, TileType, RepeatTimes)
This is what you will want to use most of the time, to splatter TileType tiles all over the map randomly. AddNoiseI function will be called RepeatTimes times.
EXAMPLE of some Scene Commands in gameplay
As I develop Traveler's Tale, an Ink & Unity game, I am writing what is in essence an "engine". It is (C#) code which parses Ink content, interprets Commands via Ink #Tags, and outputs using Unity.
Since Traveler's Tale is my attempt at creating a type of "Pen & Paper" influenced game, and my intentions are for it to be highly or fully moddable, I thought that since Ink is already the Pen, I should just get call this middleware "Paper". I intend for it to be separated into three parts: Ink (compiled JSON), C# code separate from Unity, and then Unity. This way someone could replace Unity with Godot or a custom engine while maintaining all the logic (or simply translating the C# code into C++ or whatever).
Paper Engine is a combination of a Command API & Unity, with data in Ink & JSON, as well as likely some Game Tools made with Unity (to make it very easy for any user to setup how their scene should look by setting up background images & additional images or dynamic positioning, exporting the correct tags & positions of sprites within their scene, etc.)
I hope to implement Paper Engine 1.0 with basic commands - Backgrounds, Sprites (Positioning, Flipped; No-Animation), and a few "Game Modes" such as Hexagonal Map & player movement, an inventory system, a combat positioning system, and Polyhedral Dice system (Coin, D4, D6, D8, D10, D12, D20).
The idea is to be able to just "Write" a scene & automatically see it come to life without much work on the programming side. I want my gamers to be able to take Traveler's Tale and to make & share fan-fiction of their own.
So I sell my game content
But consumers can create their own stories or fan fiction of whatever, like
#GAMEMODE:SCENE
#BACKGROUND:AlienWorld.png
#CreateSprite(FutureGuy, FuturePerson1.png)
#CreateSprite(Name2, FuturePerson2.png)
#CreateSprite(Name3, FuturePerson3.png)
#CreateSprite(Name4, FuturePerson4.png)
#CreateSprite(Name5, FuturePerson5.png)
FutureGuy: The Future is Awesome!
In essence, Paper Engine is a way to add Art & Game Systems to Ink Writing
Commands are written as shown:
**#GAMEMODE:SCENE
#BACKGROUND:COLOR(Black)"Lord Ragnavaldr and the Kwaynosian Civil War" #TITLE
#BACKGROUND:KwaynosIntro.png
In the center of all civilization dwell the flourishing citizens of Kwaynos, the largest city in the world. Not a filthy city filled with thieves and beggars, but a beacon of unity and prosperity. The Kwaynosian Humans dwell with unapologetic acceptance alongside the multitude of Half Elves and minority of Halflings which they have always welcomed as kin. All are welcome in Kwaynos, but few foreigners stay long before returning to their homeland with luxuries and wealth. Culturally, the enormous population of Humans, Half Elves, and Halflings drown out and overwhelm any foreign influence - not through force or religious zeal, but by the jovial farm-fed laziness of the region which does not give even one care for any change to their easy lifestyle.
#BACKGROUND:KwaynosianLighthouse.png
#AddSprite(Lighthouse.png, 50, 500, false)
#ContinueMaximally
The Great Kwaynosian Lighthouse shines as a beacon of trade and prosperity for both dock workers and foreign merchants alike. Rivers flow from many directions towards the Kwaynos Docks. The City's citizens are well fed, well payed, and fully unionized. It might be worth mentioning that Kwaynos is not ruled by a single King, nor an oligarchy of merchants, but by a Democratic Counsel of its citizens. But it wasn't always this way.
I hope to implement Paper Engine 2.0 with advance commands - Animation, Intelligent AI Commands, etc. The idea of Away Mission is to simply set up a Scene, give commands to AI entities, and then have the engine run the simulation with dynamic results. Dynamic AI combined with Ink's Dynamic Writing.
#AI_Action_Combat_ProtectEntity(SecurityTeam1, PeacefulCivilians)
#AI_Action_Combat_Combat(SecurityTeam2, Rebels, Stun)
#AI_Action_Movement(SecurityOfficerLead, RebelLeader, Kill)
Your Security Team attempts to protect the civilians while knocking the violent Rebels unconscious. {SecurityOfficerLeadName} however sets his Phaser on the Kill setting, with full intention of disintegrating {RebelLeaderName}.
*[Approve the plan.]
#UnpauseSimulationOnContinue
*[Command {SecurityOfficerLeadName} to set his Phaser on Stun]
-> Roll(SecurityOfficerLeadName, Loyalty, 20)
//On Failure #UnpauseSimulation
*EngineerOfficer: We only have enough time to beam up {SecurityOfficerLeadName, so if we do so you will have to trust {NextHighestRankSecurityOfficer} to take charge and perform his own plan.]
-> HostageSituation(NextHighestRankSecurityOfficer)
This way it results in animated scenes playing out, with story text displayed & player choices influencing what happens before, during, and after the scenes play out.
So earlier versions would be simpler.
#GAMEMODE:Scene
#BACKGROUND:Ship_Bridge
#DIALOGUE:GloobGlopsOfBloob(GenerateRandom_Battleship, Mood_Adversarial)
We are the Gloob glops of Bloob! Bow down before us......
*We are not intimidated ...
-> StandStrong
*Do not destroy us! ...
-> BegForMercy
*Crew, what do you think? ...
-> CrewConsultation
#GAMEMODE:Scene
#Background:CurrentPlanet
#DIALOGUE:GloobGlopsOfBloob(GenerateRandomTeam_Science, Mood_Friendly)
#SkillCheck(Translation)
//On Success
*We are the Gloobs. We welcome you to our home world. ...
//On Failure
-> GloobGlobLanguageFailText //Gloob Gloob Glob Gloob Glob Gloob.
*[Attempt to Translate Again]
//Loop, or whatever
#GAMEMODE:Map
Later versions would be more complex.
#GAMEMODE:Scene
#BACKGROUND:Ship_CargoBay
#SpawnCrew(CommunicationTeam, Communications, 9, CargoBay_RandomCrewPositions.json)
#SpawnCrew(SpecialCrew, Communications, 1, CargoBay_SpecialCrewPosition12.json)
#AI_Action_Movement(CommunicationTeam, FinishWork_ExitRoom, Queue0)
#AI_Action_Movement(SpecialCrew, CargoBay_RandomExitPosition.json, Queue0)
#AI_Action_Facing(SpecialCrew, Up, Queue1)
#Delay 2
#AI_Action_Facing(SpecialCrew, Down, Queue3)
#AI_Action_Movement(ExitRoom, SpecialCrew)
//This results in the below.
Something like that, anyway. Obviously the latter is way more complex, and very far away. It also will only happen if it is the easiest / more feasible way to handle this content. Obviously if there's a better way to write content for Away Mission other than Ink & Tag parsing, I will likely do that instead. It's too far away to really be concrete right now.
Traveler's Tale uses the basic commands though - art change, text displayed, maybe some audio effects & music playing at certain times, Dice Conflict Resolution, etc.
That's really cool. I've been keeping everything in my (visual novel/RPG adjacent) project in the ink (Unity reaches into the ink for everything story or gameplay related, it's been great for experimenting with wrappers) but your engine is both more ambitious and more versatile. Looking forward to watching it progress and checking it out once it's publicly available.
This sounds fantastic, and would fit nicely with some ink ideas that were too ambitious for me to implement on my own. Please keep us updated!
Awesome.
Interesting to see your ideas for the commands. Personally, I found this approach very quickly becoming limiting when I built my own RPG engine (originally with my own language design, later moved to Ink and used with Ink in Pirates and Traders 2 - way too many functions, parameters, etc. My solution was to allow object references as variables in Ink, as well as the possibility to call methods on those objects.
Like the approach to using the tags for this. Ink didn't have tags when I originally built mica-ink/jInk, so that was not an option at the time, but I can see how that might be a way to introduce objects while still staying compatible with Ink. Though it loses one of the advantages I like with having objects, which is the ability to easily integrate into the script; e.g.,
"Hello, my name is {player.name()!" You {{player.checkSkill("etiquette")}: bow from the waist in greeting|reach out your hand for a handshake}.
Anyway, good luck with this. Will follow with interest.
(moved all of my first posts done one, to make the OP the most up to date information)
Right now I'm engineering how everything needs to be done with Traveler's Tale.
First Features for Paper Engine (Traveler's Tale):
- #GAMEMODE:SCENE //GameMode - Story
- #BACKGROUND:ImageName //Background Scene Image
- #CreateSprite(GameObjectName, ImageName, Vector2_Position, Flipped) //Characters & Props
- #GAMEMODE:MAP //GameMode - Gameplay, Map Travel
Which should end up with gameplay like this:
All derived from just writing some story in INK, and some WorldMap/HexTile logic in JSON.
Oi, I forgot to update this whenever I update the devlog.
I will add a link to the more up to date Unity devlog in the OP.
#Tags turned out to be a poor way to handle things, due to the lack of variables & function calls.
Syntax has changed to be similar to what Inkle themselves use.
>>Command(Parameters)
And for Character related Dialogue or special text rendering (ex. Titles)
Character>:DialogueText
Title>:Lord Ragnavaldr and the Kwaynosian Civil War
I will also update at the bottom of the OP, all the currently supported commands (as they appear in my documentation). This way everyone can see the real functionality of "Paper" as it gets developed in real time. I will add only tested & finished >>Commands & Features.
I updated the OP with some links, the reasons why we are creating Paper Engine, our future plans & current situation, and general information I felt might show off what this will turn into (our games) but while keeping our expectations in check (our "part time job" reality).
I hope I was concise and brief enough, while still giving an idea what Paper Engine is & being realistic about the likelihood / timeline of development.
I have begun work earlier than expected on Procedural Generation & very likely a Game Tool for Map generation.
I've added the following commands, with success.
- >>CreateMap(MapID, MapSizeX, MapSizeY)
- >>ReplaceAllTileType(MapID, TileToReplace, NewTileType)
- >>AddNoiseI(MapID, TileType)
- >>AddNoiseI(MapID, TileType, RepeatTimes)
Here is an example of the commands written in Ink, and how they work.
{Adventure1_GenerateMap()} //Generate the Adventure1 Map - Function uses Paper Engine API
>>GAMEMODE(MAP,{Map_Adventure1}) //Start the game using the Adventure1 Map
CarterG81, has there been any progress made on this engine since last year? If it is even in a beta state, I would be interested in trying it for a project.
Like aumusic, I was wondering if it would be possible to take a look at the engine (even if it's not fully developed). It looks promising and I'd love to see if I can incorporate it into a project. Thanks!
Looks very interesting and promising. Are you going to publish the engine? I would like to try it and play with it.
I am still interested in this @CarterG81