Guides web novel writing, storytelling, and web fiction publishing. Invoke when writing web novels, creating stories, or publishing on web fiction platforms.
This skill provides comprehensive guidance for writing and publishing web novels, including storytelling techniques, character development, world-building, and platform-specific strategies.
Invoke this skill when user:
class WebNovelStructure:
"""Web novel structure and format management"""
def __init__(self, novel_title: str):
self.novel_title = novel_title
self.chapters = []
self.word_count = 0
self.readership = 0
self.platform = None
def create_chapter(self, chapter_number: int, title: str,
content: str) -> dict:
"""Create a new chapter"""
chapter = {
'number': chapter_number,
'title': title,
'content': content,
'word_count': len(content.split()),
'published_date': None,
'views': 0,
'comments': [],
'rating': 0.0
}
self.chapters.append(chapter)
self.word_count += chapter['word_count']
return chapter
def calculate_reading_time(self, chapter_number: int) -> float:
"""Calculate estimated reading time"""
if chapter_number > len(self.chapters):
return 0.0
chapter = self.chapters[chapter_number - 1]
# Average reading speed: 300 words per minute
return chapter['word_count'] / 300.0
def get_statistics(self) -> dict:
"""Get novel statistics"""
return {
'total_chapters': len(self.chapters),
'total_words': self.word_count,
'average_chapter_length': self.word_count / len(self.chapters) if self.chapters else 0,
'total_views': sum(ch['views'] for ch in self.chapters),
'average_rating': sum(ch['rating'] for ch in self.chapters) / len(self.chapters) if self.chapters else 0.0,
'total_comments': sum(len(ch['comments']) for ch in self.chapters)
}
class ChapterPlanner:
"""Chapter planning and scheduling"""
def __init__(self, update_frequency: str = 'daily'):
self.update_frequency = update_frequency
self.chapter_schedule = []
self.content_calendar = {}
def plan_chapter_arc(self, total_chapters: int,
story_points: list) -> dict:
"""Plan chapter arc with key story points"""
chapters_per_point = total_chapters // len(story_points)
plan = {
'total_chapters': total_chapters,
'key_points': {},
'pacing': self._calculate_pacing(story_points, total_chapters)
}
for i, point in enumerate(story_points):
start_chapter = i * chapters_per_point + 1
end_chapter = (i + 1) * chapters_per_point
plan['key_points'][point] = {
'start_chapter': start_chapter,
'end_chapter': end_chapter,
'chapters_allocated': end_chapter - start_chapter + 1
}
return plan
def _calculate_pacing(self, story_points: list,
total_chapters: int) -> dict:
"""Calculate pacing for story points"""
pacing = {
'fast': 0,
'medium': 0,
'slow': 0
}
chapters_per_point = total_chapters / len(story_points)
if chapters_per_point < 3:
pacing['fast'] = len(story_points)
elif chapters_per_point < 5:
pacing['medium'] = len(story_points)
else:
pacing['slow'] = len(story_points)
return pacing
def create_release_schedule(self, start_date: datetime,
chapter_count: int) -> list:
"""Create chapter release schedule"""
schedule = []
current_date = start_date
for i in range(1, chapter_count + 1):
schedule.append({
'chapter': i,
'release_date': current_date,
'status': 'scheduled'
})
# Add days based on frequency
if self.update_frequency == 'daily':
current_date += timedelta(days=1)
elif self.update_frequency == 'weekly':
current_date += timedelta(weeks=1)
elif self.update_frequency == 'biweekly':
current_date += timedelta(weeks=2)
return schedule
class PlotDeveloper:
"""Plot development and story structure"""
def __init__(self):
self.plot_points = []
self.subplots = []
self.arcs = {}
def create_three_act_structure(self, story_premise: str) -> dict:
"""Create three-act structure"""
structure = {
'act1': {
'purpose': 'Setup and inciting incident',
'percentage': 25,
'key_elements': ['introduction', 'inciting_incident', 'first_plot_point']
},
'act2': {
'purpose': 'Rising action and complications',
'percentage': 50,
'key_elements': ['rising_action', 'midpoint', 'complications']
},
'act3': {
'purpose': 'Climax and resolution',
'percentage': 25,
'key_elements': ['climax', 'falling_action', 'resolution']
}
}
return structure
def develop_character_arc(self, character_name: str,
arc_type: str = 'hero_journey') -> dict:
"""Develop character arc"""
arcs = {
'hero_journey': {
'stages': [
'ordinary_world',
'call_to_adventure',
'refusal_of_call',
'meeting_mentor',
'crossing_threshold',
'tests_allies_enemies',
'approach_inmost_cave',
'ordeal',
'reward',
'road_back',
'resurrection',
'return_with_elixir'
]
},
'redemption_arc': {
'stages': [
'flawed_character',
'catalyst_for_change',
'resistance_to_change',
'breaking_point',
'journey_of_change',
'testing_new_self',
'final_confrontation',
'redemption'
]
},
'fall_from_grace': {
'stages': [
'perfect_life',
'temptation',
'first_mistake',
'descent',
'rock_bottom',
'realization',
'attempted_redemption',
'final_fate'
]
}
}
return {
'character': character_name,
'arc_type': arc_type,
'stages': arcs.get(arc_type, {}).get('stages', [])
}
def create_subplot(self, subplot_name: str,
main_plot_chapter: int,
subplot_chapters: list) -> dict:
"""Create subplot that weaves into main plot"""
subplot = {
'name': subplot_name,
'main_plot_connection': main_plot_chapter,
'subplot_chapters': subplot_chapters,
'resolution_chapter': max(subplot_chapters),
'status': 'active'
}
self.subplots.append(subplot)
return subplot
class ConflictManager:
"""Conflict and tension management"""
def __init__(self):
self.conflicts = []
self.tension_levels = {}
def create_conflict(self, conflict_type: str,
parties: list, stakes: str) -> dict:
"""Create story conflict"""
conflict = {
'type': conflict_type, # internal, interpersonal, societal, supernatural
'parties': parties,
'stakes': stakes,
'intensity': 0.0,
'resolution': None,
'status': 'active'
}
self.conflicts.append(conflict)
return conflict
def escalate_tension(self, chapter_number: int,
tension_level: float) -> dict:
"""Escalate tension for specific chapter"""
self.tension_levels[chapter_number] = {
'level': tension_level,
'conflicts_involved': self._get_active_conflicts(chapter_number),
'climax_buildup': tension_level > 0.8
}
return self.tension_levels[chapter_number]
def _get_active_conflicts(self, chapter_number: int) -> list:
"""Get conflicts active in chapter"""
active_conflicts = []
for conflict in self.conflicts:
if conflict['status'] == 'active':
active_conflicts.append(conflict)
return active_conflicts
def resolve_conflict(self, conflict_index: int,
resolution_type: str, chapter_number: int) -> dict:
"""Resolve a conflict"""
if conflict_index >= len(self.conflicts):
return {'error': 'Conflict not found'}
conflict = self.conflicts[conflict_index]
conflict['resolution'] = {
'type': resolution_type, # victory, compromise, sacrifice, transformation
'chapter': chapter_number,
'satisfying': self._evaluate_resolution_satisfaction(conflict)
}
conflict['status'] = 'resolved'
return conflict
def _evaluate_resolution_satisfaction(self, conflict: dict) -> bool:
"""Evaluate if resolution is satisfying"""
# Check if stakes were addressed
if conflict['stakes'] not in str(conflict.get('resolution', {})):
return False
# Check if parties are involved in resolution
if not any(party in str(conflict.get('resolution', {}))
for party in conflict['parties']):
return False
return True
class CharacterCreator:
"""Character creation and development"""
def __init__(self):
self.characters = {}
self.relationships = {}
def create_character(self, name: str, role: str,
archetype: str = None) -> dict:
"""Create detailed character profile"""
character = {
'name': name,
'role': role, # protagonist, antagonist, supporting, mentor, etc.
'archetype': archetype,
'background': {},
'personality': {},
'abilities': [],
'flaws': [],
'goals': [],
'fears': [],
'relationships': [],
'development_arc': None
}
self.characters[name] = character
return character
def develop_background(self, character_name: str,
background_elements: dict) -> dict:
"""Develop character background"""
if character_name not in self.characters:
return {'error': 'Character not found'}
character = self.characters[character_name]
character['background'] = {
'origin': background_elements.get('origin', ''),
'family': background_elements.get('family', {}),
'education': background_elements.get('education', ''),
'trauma': background_elements.get('trauma', ''),
'formative_events': background_elements.get('formative_events', [])
}
return character
def define_personality(self, character_name: str,
traits: list, values: list) -> dict:
"""Define character personality"""
if character_name not in self.characters:
return {'error': 'Character not found'}
character = self.characters[character_name]
character['personality'] = {
'traits': traits, # brave, cunning, compassionate, etc.
'values': values, # honor, justice, love, etc.
'temperament': self._determine_temperament(traits),
'motivations': self._derive_motivations(traits, values)
}
return character
def _determine_temperament(self, traits: list) -> str:
"""Determine character temperament"""
positive_traits = [t for t in traits if t in ['brave', 'optimistic', 'energetic', 'outgoing']]
negative_traits = [t for t in traits if t in ['pessimistic', 'cautious', 'reserved', 'anxious']]
if len(positive_traits) > len(negative_traits):
return 'sanguine'
elif len(negative_traits) > len(positive_traits):
return 'melancholic'
else:
return 'balanced'
def _derive_motivations(self, traits: list, values: list) -> list:
"""Derive character motivations from traits and values"""
motivations = []
if 'brave' in traits and 'justice' in values:
motivations.append('protecting_others')
if 'cunning' in traits and 'power' in values:
motivations.append('gaining_control')
if 'compassionate' in traits and 'love' in values:
motivations.append('helping_others')
return motivations if motivations else ['survival']
def create_relationship(self, character1: str,
character2: str, relationship_type: str) -> dict:
"""Create relationship between characters"""
relationship = {
'character1': character1,
'character2': character2,
'type': relationship_type, # friend, enemy, mentor, romantic, family
'dynamics': {},
'development': []
}
relationship_id = f"{character1}_{character2}"
self.relationships[relationship_id] = relationship
# Update character relationship lists
if character1 in self.characters:
self.characters[character1]['relationships'].append(relationship_id)
if character2 in self.characters:
self.characters[character2]['relationships'].append(relationship_id)
return relationship
class WorldBuilder:
"""World-building and setting creation"""
def __init__(self, world_name: str):
self.world_name = world_name
self.locations = {}
self.cultures = {}
self.magic_systems = {}
self.technologies = {}
def create_location(self, location_name: str,
location_type: str, features: dict) -> dict:
"""Create detailed location"""
location = {
'name': location_name,
'type': location_type, # city, forest, dungeon, palace, etc.
'geography': features.get('geography', {}),
'climate': features.get('climate', ''),
'inhabitants': features.get('inhabitants', []),
'resources': features.get('resources', []),
'dangers': features.get('dangers', []),
'secrets': features.get('secrets', []),
'connections': []
}
self.locations[location_name] = location
return location
def create_culture(self, culture_name: str,
culture_elements: dict) -> dict:
"""Create detailed culture"""
culture = {
'name': culture_name,
'social_structure': culture_elements.get('social_structure', {}),
'religion': culture_elements.get('religion', {}),
'economy': culture_elements.get('economy', {}),
'technology_level': culture_elements.get('technology_level', ''),
'customs': culture_elements.get('customs', []),
'taboos': culture_elements.get('taboos', []),
'language': culture_elements.get('language', {}),
'arts': culture_elements.get('arts', [])
}
self.cultures[culture_name] = culture
return culture
def develop_magic_system(self, system_name: str,
system_rules: dict) -> dict:
"""Develop magic system"""
magic_system = {
'name': system_name,
'source': system_rules.get('source', ''), # mana, divine, blood, etc.
'limitations': system_rules.get('limitations', []),
'costs': system_rules.get('costs', {}),
'spells': system_rules.get('spells', []),
'schools': system_rules.get('schools', []),
'rarity_system': system_rules.get('rarity_system', {})
}
self.magic_systems[system_name] = magic_system
return magic_system
class WritingStyleManager:
"""Writing style and voice management"""
def __init__(self):
self.style_elements = {}
self.voice_characteristics = {}
def establish_voice(self, narrator_type: str,
voice_traits: dict) -> dict:
"""Establish narrative voice"""
voice = {
'narrator_type': narrator_type, # first_person, third_person_limited, third_person_omniscient
'personality': voice_traits.get('personality', {}),
'vocabulary': voice_traits.get('vocabulary', {}),
'sentence_structure': voice_traits.get('sentence_structure', {}),
'tone': voice_traits.get('tone', ''),
'perspective': voice_traits.get('perspective', '')
}
self.voice_characteristics[narrator_type] = voice
return voice
def create_style_guide(self, genre: str,
style_preferences: dict) -> dict:
"""Create style guide for genre"""
style_guide = {
'genre': genre,
'pacing': style_preferences.get('pacing', 'medium'),
'description_density': style_preferences.get('description_density', 'medium'),
'dialogue_style': style_preferences.get('dialogue_style', 'natural'),
'action_style': style_preferences.get('action_style', 'detailed'),
'emotional_depth': style_preferences.get('emotional_depth', 'medium'),
'world_building_integration': style_preferences.get('world_building', 'balanced')
}
self.style_elements[genre] = style_guide
return style_guide
def analyze_prose(self, text: str) -> dict:
"""Analyze prose characteristics"""
analysis = {
'sentence_length': self._calculate_average_sentence_length(text),
'vocabulary_complexity': self._calculate_vocabulary_complexity(text),
'dialogue_ratio': self._calculate_dialogue_ratio(text),
'action_ratio': self._calculate_action_ratio(text),
'description_ratio': self._calculate_description_ratio(text)
}
return analysis
def _calculate_average_sentence_length(self, text: str) -> float:
"""Calculate average sentence length"""
sentences = text.split('.')
word_counts = [len(sentence.split()) for sentence in sentences]
return sum(word_counts) / len(word_counts) if word_counts else 0
def _calculate_vocabulary_complexity(self, text: str) -> float:
"""Calculate vocabulary complexity"""
words = text.split()
unique_words = set(words)
return len(unique_words) / len(words) if words else 0
def _calculate_dialogue_ratio(self, text: str) -> float:
"""Calculate dialogue to narrative ratio"""
dialogue_chars = len(re.findall(r'"[^"]*"', text))
total_chars = len(text)
return dialogue_chars / total_chars if total_chars else 0
def _calculate_action_ratio(self, text: str) -> float:
"""Calculate action to description ratio"""
action_words = ['ran', 'jumped', 'fought', 'moved', 'attacked']
action_count = sum(1 for word in text.split() if word.lower() in action_words)
total_words = len(text.split())
return action_count / total_words if total_words else 0
def _calculate_description_ratio(self, text: str) -> float:
"""Calculate description to action ratio"""
description_words = ['was', 'were', 'seemed', 'appeared', 'looked']
description_count = sum(1 for word in text.split() if word.lower() in description_words)
total_words = len(text.split())
return description_count / total_words if total_words else 0
class WebNovelPlatform:
"""Web novel platform integration"""
def __init__(self, platform_name: str):
self.platform_name = platform_name
self.api_endpoint = self._get_platform_endpoint()
self.auth_token = None
def _get_platform_endpoint(self) -> str:
"""Get platform API endpoint"""
platforms = {
'qidian': 'https://api.qidian.com',
'webnovel': 'https://api.webnovel.com',
'royalroad': 'https://api.royalroad.com',
'scribblehub': 'https://api.scribblehub.com',
'wattpad': 'https://api.wattpad.com'
}
return platforms.get(self.platform_name.lower(), '')
def authenticate(self, credentials: dict) -> bool:
"""Authenticate with platform"""
auth_methods = {
'qidian': self._auth_qidian,
'webnovel': self._auth_webnovel,
'royalroad': self._auth_royalroad,
'scribblehub': self._auth_scribblehub,
'wattpad': self._auth_wattpad
}
auth_method = auth_methods.get(self.platform_name.lower())
if auth_method:
return auth_method(credentials)
return False
def publish_chapter(self, chapter_data: dict) -> dict:
"""Publish chapter to platform"""
publish_methods = {
'qidian': self._publish_qidian,
'webnovel': self._publish_webnovel,
'royalroad': self._publish_royalroad,
'scribblehub': self._publish_scribblehub,
'wattpad': self._publish_wattpad
}
publish_method = publish_methods.get(self.platform_name.lower())
if publish_method:
return publish_method(chapter_data)
return {'error': 'Platform not supported'}
def get_analytics(self) -> dict:
"""Get analytics from platform"""
analytics = {
'views': 0,
'readers': 0,
'ratings': 0.0,
'comments': 0,
'followers': 0,
'trending': False
}
# Platform-specific analytics retrieval
if self.platform_name.lower() == 'qidian':
analytics = self._get_qidian_analytics()
elif self.platform_name.lower() == 'webnovel':
analytics = self._get_webnovel_analytics()
return analytics
class ReaderCommunity:
"""Reader community and engagement management"""
def __init__(self):
self.readers = {}
self.comments = {}
self.polls = {}
self.events = {}
def analyze_reader_feedback(self, comments: list,
reviews: list) -> dict:
"""Analyze reader feedback"""
analysis = {
'sentiment': self._analyze_sentiment(comments + reviews),
'common_themes': self._extract_themes(comments + reviews),
'character_mentions': self._count_character_mentions(comments + reviews),
'plot_feedback': self._analyze_plot_feedback(comments + reviews),
'writing_feedback': self._analyze_writing_feedback(comments + reviews)
}
return analysis
def _analyze_sentiment(self, feedback: list) -> dict:
"""Analyze sentiment of feedback"""
positive_words = ['love', 'great', 'amazing', 'excellent', 'perfect']
negative_words = ['hate', 'bad', 'terrible', 'boring', 'disappointing']
sentiment_scores = []
for comment in feedback:
positive_count = sum(1 for word in comment.lower().split()
if word in positive_words)
negative_count = sum(1 for word in comment.lower().split()
if word in negative_words)
if positive_count > negative_count:
sentiment_scores.append('positive')
elif negative_count > positive_count:
sentiment_scores.append('negative')
else:
sentiment_scores.append('neutral')
return {
'positive': sentiment_scores.count('positive'),
'negative': sentiment_scores.count('negative'),
'neutral': sentiment_scores.count('neutral'),
'overall': max(set(sentiment_scores), key=sentiment_scores.count)
}
def create_poll(self, question: str, options: list) -> dict:
"""Create reader poll"""
poll = {
'question': question,
'options': options,
'votes': {option: 0 for option in options},
'total_votes': 0,
'status': 'active',
'created_at': datetime.now()
}
poll_id = str(uuid.uuid4())
self.polls[poll_id] = poll
return poll
def schedule_event(self, event_type: str,
event_details: dict) -> dict:
"""Schedule reader event"""
event = {
'type': event_type, # q_and_a, contest, celebration, etc.
'title': event_details.get('title', ''),
'description': event_details.get('description', ''),
'date': event_details.get('date'),
'duration': event_details.get('duration', '1 hour'),
'participants': [],
'status': 'scheduled'
}
event_id = str(uuid.uuid4())
self.events[event_id] = event
return event
class MonetizationManager:
"""Monetization and revenue management"""
def __init__(self):
self.revenue_streams = {}
self.subscriptions = {}
self.patreon_data = {}
def setup_patreon(self, tier_details: list) -> dict:
"""Setup Patreon tiers"""
patreon_setup = {
'tiers': {},
'goals': [],
'benefits': {},
'milestone_rewards': {}
}
for tier in tier_details:
tier_id = f"tier_{tier['level']}"
patreon_setup['tiers'][tier_id] = {
'name': tier['name'],
'price': tier['price'],
'benefits': tier.get('benefits', []),
'subscriber_count': 0,
'revenue': 0
}
self.patreon_data = patreon_setup
return patreon_setup
def calculate_potential_revenue(self, current_readers: int,
conversion_rate: float = 0.01) -> dict:
"""Calculate potential revenue"""
revenue_projections = {
'free_tier': {
'readers': current_readers,
'revenue_per_reader': 0.0,
'total_revenue': 0.0
},
'paid_tier': {
'readers': int(current_readers * conversion_rate),
'revenue_per_reader': 5.0, # Average subscription
'total_revenue': current_readers * conversion_rate * 5.0
}
}
return revenue_projections
def create_merchandise_plan(self, products: list) -> dict:
"""Create merchandise plan"""
merch_plan = {
'products': {},
'inventory': {},
'sales': {},
'revenue': 0.0
}
for product in products:
product_id = f"product_{product['name'].lower().replace(' ', '_')}"
merch_plan['products'][product_id] = {
'name': product['name'],
'type': product.get('type', 'physical'),
'cost': product.get('cost', 0.0),
'price': product.get('price', 0.0),
'profit_margin': product.get('price', 0.0) - product.get('cost', 0.0),
'inventory': 0,
'sold': 0
}
return merch_plan
Remember: Web novel writing requires consistency, reader engagement, and continuous improvement. Build a relationship with your readers and always strive to improve your craft.