Girl Kills the Dragon

[dmoonfire]

I've wanted to try NaNoGenMo for a couple years but this time, I'm going to work really hard to build up a buffer so I can actually focus on it for a month. My current idea is Girl Kills the Dragon. It will probably be written in C# because that's the language I'm most comfortable with.

Actors

The basic element of the program will be an Actor, basically a character. Actors have various aspects (I'm planning on using Fate RPG for a framework), motivations, and relationships with other characters. All actors are going to start in a neutral state.

Actors will have names and be managed by a ActorManager which is universal for the entire story even across rewrites (later).

Plots

An actor is changed by acyclic directed graph of Plot objects. These take in one or more actors, make changes, and then send them along their merry way. Since a plot is something happening, basically the novel is going to be two more plots rendered out until it makes 50k words.

Plots are going have a type based on Dwight V. Swain's Scene/Sequel. Basically, the system is going to alternate between those types (more later).

The basic plot item is the DefineActorPlot which basically creates a new actor, give them personality, attributes, and the like. There might be back story plots (ProloguePlot) to build up that character and give references (basically a character generator but those won't be written in the novel, but may be referenced). This will be something like "Mary is a girl" and basically establishes the where, what, when they begin the story. The items will also create Location objects which will eventually have a relationship with each other.

The end point is a ClimaxPlot, basically the end point. This is the "Mary kills The Dragon." There might be some plot items to tie up loose ends (EpiloguePlot). Both climaxes and defines are going to be Scene plots as opposed to Sequel plots.

The rest of the plot objects basically have a set of initial requirements (including actors), perform various operations on the actors, and then connect to another plot. A good example is the TravelPlot which basically takes one or more actors and moves them to a new location (controlled by a LocationManager).

The Novel

The initial graph is simply two DefineActorPlot (good guy and the bad guy), one travel plot(good guy goes to bad guy's location as a sequel), one bad guy does something as a sequel, and one ClimaxPlot (good guy kills bad guy).

Every plot will eventually have a time that it happens, so they can be sorted in temporal order. This makes it easy to actually write out the novel: grab all the plots, sort them chronologically, and then write them out. The version I'm aiming for this year is basically the summary but eventually each plot could be expanded into a proper prose and dialog.

Writing

The basic 5-plot chain is rather boring. So, I need to add more complexity to the story. This will effectively be an infinite loop that breaks out with certain conditions. The initial was is going to be a minimum number of non-ProloguePlot in the chain since prologues won't be written. Say, 15k plot points for a long rambling story. If I can expand plots into actual narrative, that number would go down sharply since I'll have 500 word plots instead of 5 word plots.

For every iteration, a new plot is inserted between two adjacent Plot objects. Which plot is going to be "random" (there will be a seed to produce consistent results) but there will be some rules. First, I'm going to resolve all the characters in the preceding plot (since they start neutral and have operations by the plots they are going through, I can figure out the state at any point consistently). Then, I will find all the known plot objects that have their requirements fulfilled by the preceding plot, then can fulfill the succeeding plot after the operations are done. Once I get that list, I pick a random one and insert it into the chain.

Once I do that, I resolve the scene/sequel by picking a plot to make sure it goes A/B/A/B. I also play through the rest of the plots to make sure each of those is still valid. If they aren't, then I either correct them with more plots or remove them (the rewrite phase).

Example

Using a starting example:

1. There is a actor1, they are at location1. (Scene to 2)
2. actor1 does something bad to actor2. (Sequel to 5)
3. There is a actor2, they are at location2. (Scene to 4)
4. The actor2 goes to location1. (Sequel to 5)
5. The actor2 kills actor1

Say we have a random point that introduces a new character and insert it between 4 and 5.

• There is actor3, they are at location2, they join actor2.

Now we have three characters involved in the story. However, we have two scenes together (the new 5 and 6), so we find a sequel to put between them.

• actor3 talks about backstory with actor2 (sequel)

Other Notes

That's the basic idea. I figured the complexity comes from the plot items. The above example has an ActorSet which is traveling together so actor2 and actor3 can attack actor1. I can have scenes where characters build up relationships with each other which would then let me have secondary plots. I can also backfill introduced characters so I could add some plots for actor3 to get them into the story.

Romance plots might have a "split the party for one-on-one time", "some event", "rejoin next day". This probably means I would be randomly selecting PlotFactory instead of Plot directly for the insert operations.

Plot objects will have a time to happen and time after them which would also help me figure out where to insert new plots. Also, if everything is relative, I can reference future times (you must be at the castle in {3 days}) which will change based on the intervening plot so they are always arriving at the last second.

[enkiv2]

Good to see you here :) This looks like an ambitious technique, for novel-length output.

…

On Fri, Sep 15, 2017 at 12:21 AM Dylan R. E. Moonfire < ***@***.***> wrote: I've wanted to try NaNoGenMo for a couple years but this time, I'm going to work really hard to build up a buffer so I can actually focus on it for a month. My current idea is *Girl Kills the Dragon*. It will probably be written in C# because that's the language I'm most comfortable with. Actors The basic element of the program will be an Actor, basically a character. Actors have various aspects (I'm planning on using Fate RPG for a framework), motivations, and relationships with other characters. All actors are going to start in a neutral state. Actors will have names and be managed by a ActorManager which is universal for the entire story even across rewrites (later). Plots An actor is changed by acyclic directed graph of Plot objects. These take in one or more actors, make changes, and then send them along their merry way. Since a plot is something happening, basically the novel is going to be two more plots rendered out until it makes 50k words. Plots are going have a type based on Dwight V. Swain's Scene/Sequel. Basically, the system is going to alternate between those types (more later). The basic plot item is the DefineActorPlot which basically creates a new actor, give them personality, attributes, and the like. There might be back story plots (ProloguePlot) to build up that character and give references (basically a character generator but those won't be written in the novel, but may be referenced). This will be something like "Mary is a girl" and basically establishes the where, what, when they begin the story. The items will also create Location objects which will eventually have a relationship with each other. The end point is a ClimaxPlot, basically the end point. This is the "Mary kills The Dragon." There might be some plot items to tie up loose ends ( EpiloguePlot). Both climaxes and defines are going to be Scene plots as opposed to Sequel plots. The rest of the plot objects basically have a set of initial requirements (including actors), perform various operations on the actors, and then connect to another plot. A good example is the TravelPlot which basically takes one or more actors and moves them to a new location (controlled by a LocationManager). The Novel The initial graph is simply two DefineActorPlot (good guy and the bad guy), one travel plot(good guy goes to bad guy's location as a sequel), one bad guy does something as a sequel, and one ClimaxPlot (good guy kills bad guy). Every plot will eventually have a time that it happens, so they can be sorted in temporal order. This makes it easy to actually write out the novel: grab all the plots, sort them chronologically, and then write them out. The version I'm aiming for this year is basically the summary but eventually each plot could be expanded into a proper prose and dialog. Writing The basic 5-plot chain is rather boring. So, I need to add more complexity to the story. This will effectively be an infinite loop that breaks out with certain conditions. The initial was is going to be a minimum number of non-ProloguePlot in the chain since prologues won't be written. Say, 15k plot points for a long rambling story. If I can expand plots into actual narrative, that number would go down sharply since I'll have 500 word plots instead of 5 word plots. For every iteration, a new plot is inserted between two adjacent Plot objects. Which plot is going to be "random" (there will be a seed to produce consistent results) but there will be some rules. First, I'm going to resolve all the characters in the preceding plot (since they start neutral and have operations by the plots they are going through, I can figure out the state at any point consistently). Then, I will find all the known plot objects that have their requirements fulfilled by the preceding plot, then can fulfill the succeeding plot after the operations are done. Once I get that list, I pick a random one and insert it into the chain. Once I do that, I resolve the scene/sequel by picking a plot to make sure it goes A/B/A/B. I also play through the rest of the plots to make sure each of those is still valid. If they aren't, then I either correct them with more plots or remove them (the rewrite phase). Example Using a starting example: 1. There is a actor1, they are at location1. (Scene to 2) 2. actor1 does something bad to actor2. (Sequel to 5) 3. There is a actor2, they are at location2. (Scene to 4) 4. The actor2 goes to location1. (Sequel to 5) 5. The actor2 kills actor1 Say we have a random point that introduces a new character and insert it between 4 and 5. - There is actor3, they are at location2, they join actor2. Now we have three characters involved in the story. However, we have two scenes together (the new 5 and 6), so we find a sequel to put between them. - actor3 talks about backstory with actor2 (sequel) Other Notes That's the basic idea. I figured the complexity comes from the plot items. The above example has an ActorSet which is traveling together so actor2 and actor3 can attack actor1. I can have scenes where characters build up relationships with each other which would then let me have secondary plots. I can also backfill introduced characters so I could add some plots for actor3 to get them into the story. Romance plots might have a "split the party for one-on-one time", "some event", "rejoin next day". This probably means I would be randomly selecting PlotFactory instead of Plot directly for the insert operations. Plot objects will have a time to happen and time after them which would also help me figure out where to insert new plots. Also, if everything is relative, I can reference future times (you must be at the castle in {3 days}) which will change based on the intervening plot so they are always arriving at the last second. — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub <#12>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAd6GchINi7NXiywM6l9ApXlGw31BSqUks5siftDgaJpZM4PYeM3> .

[dmoonfire]

Over the last few days, I was working on the DAG for the plots. Last night, I got the basic injection to work so the story creates a murder hobo (hero) and the Big Bad, then has the hobo go to the Big Bad and kill them. The injection inserts various abstracted detours during the murder hobo's path.

Nothing is really described, just a list of events. Descriptions are probably going to be next week.

It arranges the set of plots into chapters (breaking on different POVs, locations, or if more than hour passed) and then writes it out to a Markdown file with the output.

Development can be seen at https://gitlab.com/dmoonfire/girl-kills-dragon. It is written in C# .NET Core.

[dmoonfire]

I started checking in the current output at https://gitlab.com/dmoonfire/girl-kills-dragon/blob/master/NaNoGenMo.md This will always be updated as I go, for those who want to see the WIP.

[dmoonfire]

What goes off in your head is never how it turns out. Due to pressure from work, I was unable to work on the narrative side of things but I think I have a complicated enough plot based on the graph idea I posted in the original post. It generates a proper 50k "novel" though light on details.

The entire thing has 1,516 narrative points (leaves for somewhere, starts training, starts a fight, dies, etc.) that are actually written out with 530 plot points as back story for the various characters

It created 187 actors at 392 locations across 14 countries. The final word count was 52,587 words.

The final result, as a single Markdown file: https://gitlab.com/dmoonfire/girl-kills-dragon/blob/master/NaNoGenMo.md

# Twenty Two

This chapter is from Alex's point of view. A medium description of
Ermeyer during late morning. Zenta is already present. A reminder
description of Zenta.

Alex begin some time alone.

# Twenty Three

This chapter is from Alex's point of view. A reminder description of
Ermeyer during late evening. Alex and Zenta are already present. A
reminder description of Alex. A reminder description of Zenta.

Alex finish their time together.

Alex and Zenta begin to fight.  Alex fights alone.  Zenta fights alone.

Zenta died.

Alex finish fighting.

Alex starts to train alone.

# Twenty Four

This chapter is from Alex's point of view. A reminder description of
Ermeyer during early morning. Alex is already present. A reminder
description of Alex.

Alex finishes his training.

Alex leaves Ermeyer on the route to Bos.

@hugovk Done