ClassySK by novystxr 
Object orientation for skript in the form of classes
Events
0
Expressions
6
Effects
2
Conditions
1
Types
2
Sections
1
Structures
1
Total
13
ClassySK by novystxr
1.4.0-pre2 13 hours and 17 minutes ago
Inheritance pre-release 2
This update took a while to come out with and involved a lot of technical challenges which had to be overcome. The previous major update (1.3.0) addressed a lot of the core internal differences between the two branches, but I feel it's necessary to do this as a pre-release first to iron out bugs and make testing more accessible to those who want to.
Feedback, suggestions and bug reports for the update are welcome! Especially if you have any issues with the language design now is a good time to voice them so we can discuss before it's committed to a full release. If so please make an issue or contact me on discord! (
@novystar
) You can also leave a comment on the current inheritance PR #5 which will remain unmerged until the full release.
Fixes/Changes since last pre-release:
- Fixed the origin of anonymous methods being inaccurate, leading to access-modifiers not behaving as intended
- Fixed
super
not using the context class for the inheritance walk, meaning super calls on anonymous methods would call themselves.
- Methods now support keyed returns
Additions:
- Single class inheritance
- New modifiers:
-
protected
- Restricted to subclasses and field definitions in
new Class
sections
-
override
- In order to override a method you need to use this or you'll get an error.
-
abstract
- Abstract classes can be extended directly in code anonymously, they may also contain abstract methods which have no body and must be implemented by any inheritor.
-
final
- Final classes can't be extended, final methods can't be overridden.
- Super method calls like
super::method()
, for accessing the non-overridden version of a method (from the previous class).
- Anonymous classes: abstract classes can be implemented directly in the
new instance
section (anonymous behaviour is erased on restart)
- A dedicated 'cast' expression for upcasting in strictly typed scenarios (like using type hints):
{_var} as MyClass
Changes/fixes:
- The
instance of
condition now supports
exact instance of
for direct comparisons.
- Removed the
belongs to
pattern for class comparisons
- Method calls now support keyed return values
See the following wiki pages for a more in depth walk through of the new features for this update:
- Inheritance Overview
- Abstract & Anonymous
1.3.2 25 days, 23 hours and 31 minutes ago
1.3.2 Patch release
Changes included in this release:
- Fixed dangerous array handling during field serialization which meant an exception would be thrown when serializing numbers.
- The 'instance' part of the class-specific type pattern is no longer case sensitive.
1.3.1 35 days, 10 hours and 10 minutes ago
1.3.1 Patch release
Changes included in this release:
- Generated ClassInfos now get partially registered into the
exactClassInfos
map for compatibility reasons.
- A unique language node is now created for every generated classinfo. This means you now get more helpful errors like
The function test(Example instance) does not exist.
.
- Fixed player values in fields becoming stale once they rejoined. Fields now respect the
player variable fix
config option.
- Fixed issue with method arguments getting converted to lowercase before being parsed.
- Reverted change from the previous update of class types no longer being case sensitive. (the previous bug was found to be the real cause)
1.3.0 Feature and major patch release 39 days, 14 hours and 21 minutes ago
(Warning) Breaking changes:
- Class hints have been completely removed in this update because they were not an elegant solution and were made much less useful by the type changes in this update. As well as increasing parsing complexity a lot for a feature designed for a fairly niche scenario.
- The user pattern for non-typed instances was changed to
instance. This was necessary to fix a bug with typed expressions not converting. Additionally concrete types are no longer required to be in proper case (although this is still good practice). Keep in mind it may not immediately error since
class instance now matches as
instance of type 'class'.
Improvements
- Concrete types rework.
TypedInstanceWrapper is no longer a thing. Instances now exist as a direct subclass of
ClassInstance.
- This will improve performance for typed function arguments as it no longer needs to wrap and unwrap through converters. It should generally be on par with non-typed class arguments.
- As a result of this change, the
[un]typed %classinstance% expression has been removed as it no longer serves a purpose.
- An instance's type can now be inferred from the input expressions return type allowing for more accurate parsing if type hints are enabled or the input naturally reports typed class information. This should also make call chains much more reliable.
- Method arguments can now be marked optional by adding a
? to the end of the argument name. For example in
public example(arg1?: int), 'arg1' will be not be set if not specified by the caller.
- Static / non-static methods with the same signature can now co-exist on the same class.
- Static constant fields are now re-evaluated each time the script reloads.
Changes/Bugfixes
- Default value parsing for methods and fields is now delayed until the pre-load stage. This should allow you to reliably reference other classes/functions as default values.
- Significantly cleaned up field & serialization code. Fields no longer have their own signature data, instead it always refers to the class structure. If that field no longer exists on the class it isn't accessible on instances through normal means.
- Optimized method call caching. If a method was already figured out at parse-time it is not re-validated at runtime. Runtime re-validation now only occurs when the class of the given instance is different from the last cached method.
- Changed the
new instance section logic to support proper section claiming which allows method chaining on newly created instances, useful for builder-like classes. This also applies to any section-expression parsing throughout the addon.
set {_item} to new ItemBuilder::build():
item: diamond
name: "test"
- Concrete types rework. TypedInstanceWrapper is no longer a thing. Instances now exist as a direct subclass of ClassInstance.
- This will improve performance for typed function arguments as it no longer needs to wrap and unwrap through converters. It should generally be on par with non-typed class arguments.
- As a result of this change, the [un]typed %classinstance% expression has been removed as it no longer serves a purpose.
- An instance's type can now be inferred from the input expressions return type allowing for more accurate parsing if type hints are enabled or the input naturally reports typed class information. This should also make call chains much more reliable.
- Method arguments can now be marked optional by adding a ? to the end of the argument name. For example in public example(arg1?: int), 'arg1' will be not be set if not specified by the caller.
- Static / non-static methods with the same signature can now co-exist on the same class.
- Static constant fields are now re-evaluated each time the script reloads.
Changes/Bugfixes
- Default value parsing for methods and fields is now delayed until the pre-load stage. This should allow you to reliably reference other classes/functions as default values.
- Significantly cleaned up field & serialization code. Fields no longer have their own signature data, instead it always refers to the class structure. If that field no longer exists on the class it isn't accessible on instances through normal means.
- Optimized method call caching. If a method was already figured out at parse-time it is not re-validated at runtime. Runtime re-validation now only occurs when the class of the given instance is different from the last cached method.
- Changed the
new instance section logic to support proper section claiming which allows method chaining on newly created instances, useful for builder-like classes. This also applies to any section-expression parsing throughout the addon.
set {_item} to new ItemBuilder::build():
item: diamond
name: "test"
item: diamond
name: "test"
1.2.1 Patch release 46 days, 5 hours and 30 minutes ago
This release fixes a few bugs that were found while developing a larger update.
Changes included in this release
- Fields are no longer serialized with their type since it lead to an exception being thrown for number fields when attempting to save.
- Fixed an exception which would occur when using type hints due to field/method access expressions returning multiple of the same possible return type.
- Field/method call results are now converted before they are returned to assure runtime type safety.
- Conversion for serialized fields now happens for each element in the field (if it is a list) instead of shortcutting and converting the entire array to one type, which could cause data loss.
1.2.0 Release 69 days, 2 hours and 44 minutes ago
Constant fields
This update adds constant fields, along with some bug fixes from the last update.
public const myField: integer
public static const myField: integer = 5
public static const myField: integer = 5
Constant fields can only be set as default values, or in the new instance section. Meaning they can't be changed after creation.
Changes included in this release
- added const keyword for fields
- the variable toString for class instances no longer uses it's field contents for the hash code, meaning {var::%{_myClass}%} should produce consistent results
- registered a comparator for typed and untyped instances so now %typedinstance% is %classinstance% should consistently be true
- the typed wrapper of a specific instance is now only created once so that comparing typed instances works as intended
- reworded access errors to be more helpful and specific
- changed pattern to support new ClassName as a shortened version of new instance of ClassName
- fixed nested sections in the new instance expression to properly get the source expression before checking if it can be a section
Concrete types 74 days, 8 hours and 22 minutes ago
This update primarily adds class-specific types to classysk. This was a *big* maybe for the project so I'm excited to have this working.
Old:
function example(instance: class instance):
New:
# only instances of the class Example are accepted
function example(instance: Example instance):
function example(instance: Example instance):
Changes included in this update:
- Concrete, class-specific types
- New typed/untyped instance expression
- Types that are set to serialize as a different type are now properly converted when stored in a field.
- Fields are now properly converted on deserialization, before it would only check *if* they could convert before creating the field.
- Safe calls (like ``{_var}<>::field`` which erase parse-time type information) should now function as intended, no longer throwing a null pointer exception.
- Class names can no longer be case sensitive depending on config options, fields and methods are unaffected.
Note:
- While testing for 1.21.11 on java 25+ i ran into a warning from paper's remapper. This is a minor compatibility issue from paper trying to remap internal helper classes generated by bytebuddy. It shouldn't cause issues with the plugin's functionality. To get rid of the warning, switch to java 21 or update your server.
1.0.2 Hotfix 81 days, 14 hours and 5 minutes ago
- fixed an issue where classes would be registered before methods/field were validated meaning if it failed you would get 'A class named '%s' already exists' error. whoops
1.0.1 Hotfix 82 days, 11 hours and 49 minutes ago
Changes:
- Fixed index out of bounds exception when performing an add/remove from a single field containing no value
- Changed the method call pattern to support call chaining
- Method arguments are no longer internally formatted as lowercase, which could potentially cause issues
1.0.0 Full Release 83 days, 6 hours and 9 minutes ago
1.0.0 Full Release
Changes since the last pre-release
- New instance now supports nested sections. For example:set {_instance} to new instance of Example:
myField: new instance of Example:
otherField: 1
otherField: 2
- Methods now support keyed expressions for list arguments
- Runtime integrity check for field/method calls: prints runtime errors if the signature at runtime isn't assignable to the type reported at parse time
- Class de-registration now happens cleanly every time the structure is unloaded, no longer needing a separate clean-up listener and reducing the chance of stale classes being left in server memory. Static fields and tracked instances are now stored independently.
- Class Wrapper has been changed to Class Reference since it no longer actually wraps an instance, this has been reflected in patterns. The class reference object is planned to be used in future updates as an entry point to reflection.
- Minor method optimizations
Features included in this version
- Fields and Methods (can be static or non-static)
- Public/Private access modifiers
- Serialization for instances (can be saved after restarts)
- Parse time instance type guessing (with optional [class hints](https://github.com/novystar/ClassySK/wiki/Class-Hints))
- Ability to get the class of an instance and check what type it is
- A new instance section where you can specify initial values for fields
Pre-release #2 94 days, 11 hours and 19 minutes ago
Potentially Breaking Changes
Class Options have been outright removed. I decided to remove them while the addon is still in pre-release since they were sort of a bandaid solution for things that should really be fleshed out features. I have plans to incorporate the same functionality in better ways (like additional keywords.. etc)
Other Changes:
- Added -> to the method return pattern so now you can do public myMethod() -> boolean
- Instead of if {_instance} is an instance of MyClass you can now also do if {_instance} belongs to MyClass
- Fixed a bug with the cleanup manager where it would throw an exception if the script of a class was deleted or renamed without reloading the script.
- Now checks the case sensitive config option rather than case-insensitive variables for if classes/methods/fields should be case sensitive.
- Internal rework of the class structure, better entry validation and actually fails to parse if there was an error. Additionally, SecMethod and EffField are no longer registered globally. In theory this should ensure conflicts dont happen and slightly reduce parse times.
ClassySK 101 days, 8 hours and 25 minutes ago
ClassySK is an addon that adds proper object orientation capabilities to skript in the form of classes. Allowing you to write powerful, defensive code and explore OOP concepts within skript!
Roadmap
Nothing here is set in stone but these are my future ambitions regarding the project (in no particular order)
- Inheritance: extending other classes
- Abstract Methods: unimplemented methods that should be implemented by inheritors
- Transient fields: Fields that don't get saved
- Method and Field Reflection
Code Examples
class SmartActionBar:
public player: player
public refreshRate: integer = 1
private isActive: boolean = false
private values: strings
public play(value: string, duration: timespan):
add {_value} to self::values
if self::isActive is false:
self::start()
wait {_duration}
remove {_value} from self::values
public start():
set self::isActive to true
while self::isActive is true:
if size of self::values is 0:
exit loop
set {_text} to join self::values with "&7 | &r"
send action bar {_text} ? "" to self::player
wait self::refreshRate*1 tick
send action bar "" to self::player
set self::isActive to false
public player: player
public refreshRate: integer = 1
private isActive: boolean = false
private values: strings
public play(value: string, duration: timespan):
add {_value} to self::values
if self::isActive is false:
self::start()
wait {_duration}
remove {_value} from self::values
public start():
set self::isActive to true
while self::isActive is true:
if size of self::values is 0:
exit loop
set {_text} to join self::values with "&7 | &r"
send action bar {_text} ? "" to self::player
wait self::refreshRate*1 tick
send action bar "" to self::player
set self::isActive to false
set {-actionBar::%player%} to new instance of SmartActionBar:
player: player
refreshRate: 1
{-actionBar::%player%}::play("<red>cool text", 3 seconds)
player: player
refreshRate: 1
{-actionBar::%player%}::play("<red>cool text", 3 seconds)