Text/Lua Version

[paulovbettio]

Conduits could have a way of working in a text-based manner. We can discuss the design and how it could work here.

[caysevdam]

well i dont know lua to be honest, it doesnt have OOP but it lets you do that using tables + metatables ive heard. Here is my idea in c# workflow that can be transformed into lua if possible

There will be non-static classes such as Player,WorldObject, and the types that inherit from WorldObject (eg: Textbox,Model) those will provide some functions per object (eg for player: get_name(), get_health(), get_id() ) and they will also provide some static functions for the type definition itself (eg for WorldObject: get_total_object_count() ) //the naming definetly can be improved :D

there will be static classes such as Room, World and they will have functions that will help the scripter. (eg for World: set_water_color(), set_sky_color(), eg for Room: BanPlayer(), KickPlayer() )

summary:

non-static types: Player, WorldObject and those who inherit from that
static types: Room, World, Team, Game (it will include functions such as getting game info/title/description , winning/losing game, leaderboard stuff etc) , Round (it will include sub-rounds too)

extra for the Player Class im thinking of a Role list would be really good. During the game, the script can attach specific roles created by the script to a specific player, or a group of players. Not only that the role type can also recieve parameters, letting creators create more detailed game round systems etc ig.

i think this idea is great, and probbably its possible to do this in lua, i currently didnt give what functions what type is going to have but im thinking of it rn

[caysevdam]

I have thought of some functions & things for conduits in the way i said before here they are:

World:
void set_sky(Sky sky) //the Sky type will include things for sky etc cloud color
Sky get_sky()
void set_water(Water water) //the Water type is gonna include things for water props etc
Water get_water()
lerp(float a,float b,float t) //classic lerp
slerp(float a,float b,float t) //classic slerp
//idk why i put the last 2 there i couldnt find anywhere else

Game:
Lose() | Lose(Player player) | Lose (Player[] players) //lose will make a player lose and wait till next round, also it will mark them as lost (for the current round)
Win() | Win(Player player) | Win(Player[] players) //this will make a player win and will mark them as won (for the current round)
StartRound() //manually starting the round
EndRound() | EndRound(float time) | EndRound(bool auto) //it will end the round, second overload here is for specifying a custom waiting time for the next round to be created, the third is for it to choose to create the new round automatically , if true it will wait for some time and then create a new round then start that round,(literally the same behaviour as EndRound() ) if false it will not create the new round unless new_round() has been called
Player[] get_winners() //will return the players who has won the current round
Player[] get_losers() //bruh this naming 😭
bool HasRoundStarted()
bool HasRoundEnded()
int get_Round() //the amount of rounds that has been created since the start of the Room
new_round() | new_round(float time) | new_round(bool auto) //creates a new round, makes the round counter increment, btw creating a new round will auto start the new round, the second overload is responsible for waiting some time and starting the round, while the third overload just creates the round and starts the round based on the parameter it recieves
long get_round_start() //will return the rounds start time in unix timestamp
long get_round_end() //will return the rounds end time in unix timestamp

Role:
string name; (field)
object[] parameters; (field)
object[] get_parameters() (method)
object get_parameter(int index) (method)
void set_parameter(int index, object parameter) (method)

Player:
string get_name()
int get_health()
void set_health()
Role get_role(string name)
void set_role(string name, Role role)
Role[] get_roles() //or List or Span
Role get_role_at_index(int index)
int get_id()
vector3 get_position()
void set_position(vector3 pos)
vector3 get_rotation()
void set_rotation(vector3 rot)
void slerp_rotation(vector3 rot,float delta)
void look_at_pos(vector3 pos) //makes player look into a specific position in the world space
float get_size() //here its size not scale and its a float, it can be weird if scripter did things like 100,1,5 scale for an avatar so i think we should just give them a raw float value that will apply to all of the scale axis to the avatars transform
void set_size(float size)
Item[] get_items() //inventory system type shi
Item get_item(int index)
void set_item(int index, Item item)
Team get_team()
void set_team(Team team) //team stuff etc
Class get_class()
void set_class() //classes like in kogama stuff that feature custom avatars
bool get_win_state() //returns true if player has won
bool get_lose_state() //returns true if player has lost
//well thats it for now on player but i think functions releated to avatar limbs etc can be added like changing a specific limb of a player or change the whole avatar, eg: some creator will get the player avatar limbs Voxels and change the voxels color there to black and make the characther stay in its shape but in black color now

WorldObject:
void DuplicateObject() | void DuplicateObject(vector3 new_pos,vector3 new_rotation)
void set_position(vector3 pos)
vector3 get_position()
void set_rotation(vector3 rot)
vector3 get_rotation()
float get_id()
object[] get_object_metadata() //metadata is for storing specific data in specific objects , eg storing a voxel data just for some model in the game and changing between models on the game

Model (inherits from WorldObject):
overrides void DuplicateObject(vector3 new_pos,vector3 new_rotation) to void DuplicateObject(vector3 new_pos,vector3 new_rotation,float size)
float get_size()
void set_size(float size)
bool get_visiblity()
void set_visibliy(bool visiblity)
void toggle_visiblity()
float get_opacity()
void set_opacity(float opacity)
bool get_collision() //stands for getting is the collision disabled or not, not getting the whole collision or anything like that
void set_collision(bool collision)
void toggle_collision()
Voxel get_model() //getting the model's blocks data
void set_model(Voxel model)

thats the types im thinking (not all of them obv) , i think its possible to do a system in lua that matches this