Without there being a suitable replacement for DBO, I’m starting an official thread here for KraftRPG until there is an official replacement.
KraftRPG never made it to release on Bukkit, but the API is easily modifiable to port it to most any ServerModAPI (in this case, Sponge), so, as soon as Sponge is in a more developed stage, early builds of KraftRPG will be made available for testing.
CurrentDiscussion
KraftRPG is in the transition to being implemented on SpongeAPI. Several modifications were necessary to support the transition that warranted a cease on development to support the now deprecated Bukkit API.
###KraftRPG will attempt to have the following features either on release or shortly after:
Skills
Modular skills that can be designed with ease
Skill templates provided to further simplify the design for the skill developer
Utilizes SkillArguments for argument validation and possible tab completion
SkillConfiguration validation where the developer making anything configurable will show up in the default global skill config file
Complete abstraction of skills allows for third party implementations to be used.
SkillCaster interface allows for any object in the game to use a skill (Imagine, a Dispenser casting skills).
Effects - Creating customizable behaviors
Effects can be applied to virtually anything to have a specific behavior.
Ability to mark an Entity with specific identifiable effects
Expandable library of common effect types to further simplify behaviors
Entities
Expandable interfaces defining an entity
Make any entity a SkillCaster
Complete customization with EntityManager#addEntity(IEntity) for third party implementations (think NPC’s)
Insentient entities represent the normal damageable entities in the game and can be affected by Effects
IEntity is a standard entity that KraftRPG knows about and tracks
Sentient entities can have Roles and therefore gain experience in said roles and levels can affect their maximum health
SkillCasters expand on Sentients by being able to cast Skills
Summons expand on Insentient by being linked to a SkillCaster that summoned them
Monsters expand on Insentient by having customizable damage and drop experience to their killer
Champions represent the player, all champions are SkillCasters by default and have their stats saved
Roles
Represents a notion that can gain experience of various types
Levels can grant various benefits such as increased health, increased health regeneration, increased mana, skill usage
Roles can have different configurations for skills to provide a more customized experience
Custom definitions of damage for a specific Item type
Loose dependency tree can be created at any complexity wanted with the guarantee that there are no circular dependencies
Storage
Abstracted storage system allows for easy third party implementations to save player data.
Commands
A unique command system that allows configuring everything about the plugin in game (some configuration changes may only show their effects after a server restart)
Expandability
By design, KraftRPG intends to make it possible for other plugins and mods to further interact with the behaviors of KraftRPG
Dynamic on-load registration of Skills allows for “Skill Bundles” to exist.
Abstract API designed to be portable to Sponge
The feature list is quiet large, but rest assured, most of the list is written at an API level, most of the work needing to be done is on writing the base implementation on SpongeAPI when SpongeAPI is in a more usable state.
###KraftRPG is open source and its Bukkit implementations can be viewed here:
It does seem a bit similar in terms of the core functionality attempted to being achieved, though both projects seem to have different goals and are in different stages of development (at least, in my opinion).
Make sure you take the time to do documentation and examples of how to set this up before you ‘throw it against the wall to see what sticks’. Way, way, way too many Bukkit RPG plugins never bothered to do anything beyond very simple examples of things. Not that it’s above my IQ, I just don’t want to have to spend the time figuring out your stuff - I’d rather be playing…
“I’d rather be playing” There will likely be servers with that mod installed. You dont have to make server to play.
Plugin seems great. Im planning to use some of these RP plugins on my survival server to bring more in-depth experience.
Nice seeing you here I’ve had some thoughts on asking people to bounce ideas for making the skill/effects api a bit better, more diverse, etc. So, there is a nice way of doing that: http://bugs.afterkraft.com/ I’m still working on documenting a realistic roadmap of the various issues and features needing to be added/implemented.
I’m definitely open for discussion in regards to adding to the API to make it possible for different styles of skill usages to be possible (think MagicSpells, McMMO, etc.).
Having some fun with porting the API to Forge for the mean time. I’d like some ideas in terms of extra features for expandability.
So far, I’ve thought that it would be really easy to provide a Skill bundle and role bundle that replicate the feature set of McMMO. Seeing as many servers have liked the simplicity of McMMO’s play style, I don’t see why it wouldn’t be a bad idea to provide a similar play style option.
So far, my current options are to make KraftRPG-API dependent on a platform API (in this case, Sponge) or make KraftRPG-API platform independent.
Here’s the pros and cons:
Platform Dependent: Pros
All skill API is knowledgable of the platform API’s own API for ItemStacks, Entities and more.
Configuration management is handled by the platform
ItemStacks are easily created for the platform and the API will freely accept the platform specific ItemStacks
Likewise, Entities are easily understood by the platform, so, creating EntitySkillArguments to match specific Entities is feasible (as long as the platform has a hierarchical inheritance for entities).
Access to event-related API is simple, and creating listeners is easily supported.
Cons
Skills written for a platform dependent API means that they will never be compatible with the API ported for a different platform (think Bukkit plugins and Sponge plugins).
Suffer from possible API breakages from platform changes that will require skills to be updated.
Porting KraftRPG to another platform requires equal amounts of work to port, and bugs in the API may require further testing to port to other platforms.
API is purely dependent on the common data structures for Entities, Items, Locations, Vectors, Events, Blocks, Particles, Effects.
Platform Independent: Pros
KraftRPG-API is fleshed out enough to ensure minimal platform dependent operations will be needed.
Skills will be easily brought to different platforms without much issue
Common Classes in the API will provide easy understanding of various aspects of vanilla Minecraft items. Skills will not have to worry about the intricacies of various platforms behavior.
A wrapper-like implementation for each platform is easily written and API behaviors can be strictly maintained across platforms.
Skills can depend on a ‘PlatformX-Commons’ library for Platform specific API implementations without relying on the plugin implementation for that platform to still access Platform specific API.
Cons
Skills have no access to platform API
Skills dependent on a Platform API may become dependent on a secondary ‘Commons-Library’ for translating between the platform API and KraftRPG-API.
Skills requiring further integration with platform specific plugins will be platform specific, causing a confusion between platform agnostic skills and platform dependent skills.
KraftRPG as a plugin for a specific platform becomes relatively heavy in size (API + Commons + Platform Implementation)
Configurations may not be portable across platforms
Events become platform dependent, and skills listening for said events become an issue.
More work is required to provide various platform updates for KraftRPG overall.
To be honest, I’ve been considering this platform independence for a short while, considering that KraftRPG may eventually become a mod/plugin for various other platforms (such as Forge and Glowstone). The advantages is that the API becomes fully testable, and the commons become fully testable (except for a few cases), and truly, any platform developer may adapt KraftRPG for that specific platform.
I don’t expect much discussion from a Sponge platform perspective, but from some experienced developers, I do wish some insight on the matter.
I can’t really provide any insight from a programming standpoint, having never cared about porting any of my work anywhere except Bukkit (until recently). However…
It seems as though most of the cons for making KraftRPG platform independent revolve more around how much work updating it would take, rather than actual cons about its performance/usability. If putting forth that work would be something you’re comfortable doing (and might even have some fun at), I’d say go for it. Ultimately, it would reach more people.
Right, and the bit about some advanced skills being platform dependent if I got the Platform Agnostic route? I mean, the disadvantage is that most skills will require some sort of obscure interactions with the platform (as I remember having to do with Bukkit), or interact with other plugins such that KraftRPG would still understand those skills, but the common server owner would likely come complaining to me about a specific skill not working on a different platform.
It’s kinda like the issue of a Bukkit plugin using (CraftBukkit provided) NMS or CB code to do some things and then come the next update of CraftBukkit, the skill breaks.
After much consideration, I’ve decided to keep KraftRPG dependent on Sponge API. The reasons for this are as follows:
KraftRPG will not have differing implementations across platforms, reducing the maintenance workload for me to update them when one platform updates vs another.
KraftRPG API will have full access to Sponge’s API, allowing for KraftRPG API to focus on the RPG aspects, leading to an overall better RPG API.
Skills would not have to be written to support various platforms, only one platform is required.
As long as Sponge API is implemented on a platform, KraftRPG will work with that platform.
So now, I’m working to refactor the API yet again to depend on SpongeAPI and continue writing an implementation for the late CraftBukkit server for more testing and API development ideas.
Love the project so far. Just started browsing the API. I have limited Java knowledge and am looking for an RPG plugin that let’s me design my own classes and abilities as well as having functionality to restrict armor and weapon use between classes. I.E. Archer cannot use diamond armor. Speaking of archers, something that can interact with bows as well. Is this the plugin for me? Either way, consider me a supporter and a fan.
I’ve been lurking on the Git, watching progress. 