hertog/godot-module-template
Template
2
1
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Brand new networked multiplayer

Browse source
This commit is contained in:
Juan Linietsky 2016-08-19 16:48:08 -03:00
parent 56fa741b7a
commit 1add52b55e
23 changed files with 1312 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

6
modules/gdscript/gd_compiler.cpp
View file

@ -1297,8 +1297,10 @@ Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode *
gdfunc = p_script->member_functions[func_name];
//}
if (p_func)
if (p_func) {
gdfunc->_static=p_func->_static;
gdfunc->rpc_mode=p_func->rpc_mode;
}
#ifdef TOOLS_ENABLED
gdfunc->arg_names=argnames;
@ -1625,6 +1627,8 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa
minfo.index = p_script->member_indices.size();
minfo.setter = p_class->variables[i].setter;
minfo.getter = p_class->variables[i].getter;
minfo.rpc_mode=p_class->variables[i].rpc_mode;
p_script->member_indices[name]=minfo;
p_script->members.insert(name);

28
modules/gdscript/gd_editor.cpp
View file

@ -1463,7 +1463,7 @@ static void _make_function_hint(const GDParser::FunctionNode* p_func,int p_argid
}
static void _find_type_arguments(const GDParser::Node*p_node,int p_line,const StringName& p_method,const GDCompletionIdentifier& id, int p_argidx, Set<String>& result, String& arghint) {
static void _find_type_arguments(GDCompletionContext& context,const GDParser::Node*p_node,int p_line,const StringName& p_method,const GDCompletionIdentifier& id, int p_argidx, Set<String>& result, String& arghint) {
//print_line("find type arguments?");
@ -1700,9 +1700,31 @@ static void _find_type_arguments(const GDParser::Node*p_node,int p_line,const St
if (p_argidx==0) {
List<MethodInfo> sigs;
ObjectTypeDB::get_signal_list(id.obj_type,&sigs);
if (id.script.is_valid()) {
id.script->get_script_signal_list(&sigs);
} else if (id.value.get_type()==Variant::OBJECT) {
Object *obj = id.value;
if (obj && !obj->get_script().is_null()) {
Ref<Script> scr=obj->get_script();
if (scr.is_valid()) {
scr->get_script_signal_list(&sigs);
}
}
}
for (List<MethodInfo>::Element *E=sigs.front();E;E=E->next()) {
result.insert("\""+E->get().name+"\"");
}
} else if (p_argidx==2){
if (context._class) {
for(int i=0;i<context._class->functions.size();i++) {
result.insert("\""+context._class->functions[i]->name+"\"");
}
}
}
/*if (p_argidx==2) {
@ -1944,7 +1966,7 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No
if (!context._class->owner)
ci.value=context.base;
_find_type_arguments(p_node,p_line,id->name,ci,p_argidx,result,arghint);
_find_type_arguments(context,p_node,p_line,id->name,ci,p_argidx,result,arghint);
//guess type..
/*
List<MethodInfo> methods;
@ -1967,7 +1989,7 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No
GDCompletionIdentifier ci;
if (_guess_expression_type(context,op->arguments[0],p_line,ci)) {
_find_type_arguments(p_node,p_line,id->name,ci,p_argidx,result,arghint);
_find_type_arguments(context,p_node,p_line,id->name,ci,p_argidx,result,arghint);
return;
}

1
modules/gdscript/gd_function.cpp
View file

@ -1309,6 +1309,7 @@ GDFunction::GDFunction() : function_list(this) {
_stack_size=0;
_call_size=0;
rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
name="<anonymous>";
#ifdef DEBUG_ENABLED
_func_cname=NULL;

12
modules/gdscript/gd_function.h
View file

@ -7,6 +7,7 @@
#include "variant.h"
#include "string_db.h"
#include "reference.h"
#include "script_language.h"
class GDInstance;
class GDScript;
@ -64,6 +65,14 @@ public:
ADDR_TYPE_NIL=8
};
enum RPCMode {
RPC_DISABLED,
RPC_ENABLED,
RPC_SYNC,
RPC_SYNC_MASTER,
RPC_SYNC_SLAVE
};
struct StackDebug {
int line;
@ -91,6 +100,8 @@ friend class GDCompiler;
int _call_size;
int _initial_line;
bool _static;
ScriptInstance::RPCMode rpc_mode;
GDScript *_script;
StringName name;
@ -185,6 +196,7 @@ public:
Variant call(GDInstance *p_instance,const Variant **p_args, int p_argcount,Variant::CallError& r_err,CallState *p_state=NULL);
_FORCE_INLINE_ ScriptInstance::RPCMode get_rpc_mode() const { return rpc_mode; }
GDFunction();
~GDFunction();
};

99
modules/gdscript/gd_parser.cpp
View file

@ -2075,6 +2075,7 @@ void GDParser::_parse_class(ClassNode *p_class) {
if (error_set)
return;
if (indent_level>tab_level.back()->get()) {
p_class->end_line=tokenizer->get_token_line();
return; //go back a level
@ -2371,6 +2372,9 @@ void GDParser::_parse_class(ClassNode *p_class) {
function->_static=_static;
function->line=fnline;
function->rpc_mode=rpc_mode;
rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
if (_static)
p_class->static_functions.push_back(function);
@ -2842,25 +2846,101 @@ void GDParser::_parse_class(ClassNode *p_class) {
}
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_ONREADY && tokenizer->get_token()!=GDTokenizer::TK_PR_REMOTE && tokenizer->get_token()!=GDTokenizer::TK_PR_MASTER && tokenizer->get_token()!=GDTokenizer::TK_PR_SLAVE && tokenizer->get_token()!=GDTokenizer::TK_PR_SYNC) {
current_export=PropertyInfo();
_set_error("Expected 'var', 'onready', 'remote', 'master', 'slave' or 'sync'.");
return;
}
continue;
} break;
case GDTokenizer::TK_PR_ONREADY: {
//may be fallthrough from export, ignore if so
tokenizer->advance();
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
_set_error("Expected 'var'.");
return;
}
}; //fallthrough to var
case GDTokenizer::TK_PR_ONREADY: {
continue;
} break;
case GDTokenizer::TK_PR_REMOTE: {
if (token==GDTokenizer::TK_PR_ONREADY) {
//may be fallthrough from export, ignore if so
tokenizer->advance();
//may be fallthrough from export, ignore if so
tokenizer->advance();
if (current_export.type) {
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
_set_error("Expected 'var'.");
return;
}
} else {
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
_set_error("Expected 'var' or 'func'.");
return;
}
}
}; //fallthrough to var
rpc_mode=ScriptInstance::RPC_MODE_REMOTE;
continue;
} break;
case GDTokenizer::TK_PR_MASTER: {
//may be fallthrough from export, ignore if so
tokenizer->advance();
if (current_export.type) {
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
_set_error("Expected 'var'.");
return;
}
} else {
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
_set_error("Expected 'var' or 'func'.");
return;
}
}
rpc_mode=ScriptInstance::RPC_MODE_MASTER;
continue;
} break;
case GDTokenizer::TK_PR_SLAVE: {
//may be fallthrough from export, ignore if so
tokenizer->advance();
if (current_export.type) {
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
_set_error("Expected 'var'.");
return;
}
} else {
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
_set_error("Expected 'var' or 'func'.");
return;
}
}
rpc_mode=ScriptInstance::RPC_MODE_SLAVE;
continue;
} break;
case GDTokenizer::TK_PR_SYNC: {
//may be fallthrough from export, ignore if so
tokenizer->advance();
if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
if (current_export.type)
_set_error("Expected 'var'.");
else
_set_error("Expected 'var' or 'func'.");
return;
}
rpc_mode=ScriptInstance::RPC_MODE_SYNC;
continue;
} break;
case GDTokenizer::TK_PR_VAR: {
//variale declaration and (eventual) initialization
@ -2884,8 +2964,12 @@ void GDParser::_parse_class(ClassNode *p_class) {
member.expression=NULL;
member._export.name=member.identifier;
member.line=tokenizer->get_token_line();
member.rpc_mode=rpc_mode;
tokenizer->advance();
rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
if (tokenizer->get_token()==GDTokenizer::TK_OP_ASSIGN) {
#ifdef DEBUG_ENABLED
@ -3228,6 +3312,7 @@ void GDParser::clear() {
current_class=NULL;
completion_found=false;
rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
current_function=NULL;

8
modules/gdscript/gd_parser.h
View file

@ -33,6 +33,7 @@
#include "gd_functions.h"
#include "map.h"
#include "object.h"
#include "script_language.h"
class GDParser {
public:
@ -88,6 +89,7 @@ public:
StringName getter;
int line;
Node *expression;
ScriptInstance::RPCMode rpc_mode;
};
struct Constant {
StringName identifier;
@ -119,12 +121,13 @@ public:
struct FunctionNode : public Node {
bool _static;
ScriptInstance::RPCMode rpc_mode;
StringName name;
Vector<StringName> arguments;
Vector<Node*> default_values;
BlockNode *body;
FunctionNode() { type=TYPE_FUNCTION; _static=false; }
FunctionNode() { type=TYPE_FUNCTION; _static=false; rpc_mode=ScriptInstance::RPC_MODE_DISABLED; }
};
@ -429,6 +432,9 @@ private:
PropertyInfo current_export;
ScriptInstance::RPCMode rpc_mode;
void _set_error(const String& p_error, int p_line=-1, int p_column=-1);
bool _recover_from_completion();

46
modules/gdscript/gd_script.cpp
View file

@ -250,7 +250,7 @@ void GDScript::_update_placeholder(PlaceHolderScriptInstance *p_placeholder) {
#endif
void GDScript::get_method_list(List<MethodInfo> *p_list) const {
void GDScript::get_script_method_list(List<MethodInfo> *p_list) const {
for (const Map<StringName,GDFunction*>::Element *E=member_functions.front();E;E=E->next()) {
MethodInfo mi;
@ -1300,6 +1300,46 @@ ScriptLanguage *GDInstance::get_language() {
return GDScriptLanguage::get_singleton();
}
GDInstance::RPCMode GDInstance::get_rpc_mode(const StringName& p_method) const {
const GDScript *cscript = script.ptr();
while(cscript) {
const Map<StringName,GDFunction*>::Element *E=cscript->member_functions.find(p_method);
if (E) {
if (E->get()->get_rpc_mode()!=RPC_MODE_DISABLED) {
return E->get()->get_rpc_mode();
}
}
cscript=cscript->_base;
}
return RPC_MODE_DISABLED;
}
GDInstance::RPCMode GDInstance::get_rset_mode(const StringName& p_variable) const {
const GDScript *cscript = script.ptr();
while(cscript) {
const Map<StringName,GDScript::MemberInfo>::Element *E=cscript->member_indices.find(p_variable);
if (E) {
if (E->get().rpc_mode) {
return E->get().rpc_mode;
}
}
cscript=cscript->_base;
}
return RPC_MODE_DISABLED;
}
void GDInstance::reload_members() {
#ifdef DEBUG_ENABLED
@ -1811,6 +1851,10 @@ void GDScriptLanguage::get_reserved_words(List<String> *p_words) const {
"pass",
"return",
"while",
"remote",
"sync",
"master",
"slave",
0};

101
modules/gdscript/gd_script.h
View file

@ -64,6 +64,7 @@ class GDScript : public Script {
int index;
StringName setter;
StringName getter;
ScriptInstance::RPCMode rpc_mode;
};
friend class GDInstance;
@ -181,7 +182,7 @@ public:
bool get_property_default_value(const StringName& p_property,Variant& r_value) const;
virtual void get_method_list(List<MethodInfo> *p_list) const;
virtual void get_script_method_list(List<MethodInfo> *p_list) const;
virtual bool has_method(const StringName& p_method) const;
virtual MethodInfo get_method_info(const StringName& p_method) const;
@ -236,6 +237,10 @@ public:
void reload_members();
virtual RPCMode get_rpc_mode(const StringName& p_method) const;
virtual RPCMode get_rset_mode(const StringName& p_variable) const;
GDInstance();
~GDInstance();
@ -250,23 +255,23 @@ class GDScriptLanguage : public ScriptLanguage {
Map<StringName,int> globals;
struct CallLevel {
struct CallLevel {
Variant *stack;
GDFunction *function;
GDInstance *instance;
int *ip;
int *line;
Variant *stack;
GDFunction *function;
GDInstance *instance;
int *ip;
int *line;
};
};
int _debug_parse_err_line;
String _debug_parse_err_file;
String _debug_error;
int _debug_call_stack_pos;
int _debug_max_call_stack;
CallLevel *_call_stack;
int _debug_parse_err_line;
String _debug_parse_err_file;
String _debug_error;
int _debug_call_stack_pos;
int _debug_max_call_stack;
CallLevel *_call_stack;
void _add_global(const StringName& p_name,const Variant& p_value);
@ -288,54 +293,54 @@ public:
int calls;
bool debug_break(const String& p_error,bool p_allow_continue=true);
bool debug_break_parse(const String& p_file, int p_line,const String& p_error);
bool debug_break(const String& p_error,bool p_allow_continue=true);
bool debug_break_parse(const String& p_file, int p_line,const String& p_error);
_FORCE_INLINE_ void enter_function(GDInstance *p_instance,GDFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
_FORCE_INLINE_ void enter_function(GDInstance *p_instance,GDFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
if (Thread::get_main_ID()!=Thread::get_caller_ID())
return; //no support for other threads than main for now
if (Thread::get_main_ID()!=Thread::get_caller_ID())
return; //no support for other threads than main for now
if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() +1 );
if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() +1 );
if (_debug_call_stack_pos >= _debug_max_call_stack) {
//stack overflow
_debug_error="Stack Overflow (Stack Size: "+itos(_debug_max_call_stack)+")";
ScriptDebugger::get_singleton()->debug(this);
return;
if (_debug_call_stack_pos >= _debug_max_call_stack) {
//stack overflow
_debug_error="Stack Overflow (Stack Size: "+itos(_debug_max_call_stack)+")";
ScriptDebugger::get_singleton()->debug(this);
return;
}
_call_stack[_debug_call_stack_pos].stack=p_stack;
_call_stack[_debug_call_stack_pos].instance=p_instance;
_call_stack[_debug_call_stack_pos].function=p_function;
_call_stack[_debug_call_stack_pos].ip=p_ip;
_call_stack[_debug_call_stack_pos].line=p_line;
_debug_call_stack_pos++;
}
_call_stack[_debug_call_stack_pos].stack=p_stack;
_call_stack[_debug_call_stack_pos].instance=p_instance;
_call_stack[_debug_call_stack_pos].function=p_function;
_call_stack[_debug_call_stack_pos].ip=p_ip;
_call_stack[_debug_call_stack_pos].line=p_line;
_debug_call_stack_pos++;
}
_FORCE_INLINE_ void exit_function() {
_FORCE_INLINE_ void exit_function() {
if (Thread::get_main_ID()!=Thread::get_caller_ID())
return; //no support for other threads than main for now
if (Thread::get_main_ID()!=Thread::get_caller_ID())
return; //no support for other threads than main for now
if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() -1 );
if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() -1 );
if (_debug_call_stack_pos==0) {
if (_debug_call_stack_pos==0) {
_debug_error="Stack Underflow (Engine Bug)";
ScriptDebugger::get_singleton()->debug(this);
return;
}
_debug_error="Stack Underflow (Engine Bug)";
ScriptDebugger::get_singleton()->debug(this);
return;
}
_debug_call_stack_pos--;
}
_debug_call_stack_pos--;
}
virtual Vector<StackInfo> debug_get_current_stack_info() {
if (Thread::get_main_ID()!=Thread::get_caller_ID())
return Vector<StackInfo>();
if (Thread::get_main_ID()!=Thread::get_caller_ID())
return Vector<StackInfo>();
Vector<StackInfo> csi;
csi.resize(_debug_call_stack_pos);

10
modules/gdscript/gd_tokenizer.cpp
View file

@ -100,6 +100,10 @@ const char* GDTokenizer::token_names[TK_MAX]={
"yield",
"signal",
"breakpoint",
"rpc",
"sync",
"master",
"slave",
"'['",
"']'",
"'{'",
@ -865,6 +869,10 @@ void GDTokenizerText::_advance() {
{TK_PR_YIELD,"yield"},
{TK_PR_SIGNAL,"signal"},
{TK_PR_BREAKPOINT,"breakpoint"},
{TK_PR_REMOTE,"remote"},
{TK_PR_MASTER,"master"},
{TK_PR_SLAVE,"slave"},
{TK_PR_SYNC,"sync"},
{TK_PR_CONST,"const"},
//controlflow
{TK_CF_IF,"if"},
@ -1047,7 +1055,7 @@ void GDTokenizerText::advance(int p_amount) {
//////////////////////////////////////////////////////////////////////////////////////////////////////
#define BYTECODE_VERSION 10
#define BYTECODE_VERSION 11
Error GDTokenizerBuffer::set_code_buffer(const Vector<uint8_t> & p_buffer) {

4
modules/gdscript/gd_tokenizer.h
View file

@ -107,6 +107,10 @@ public:
TK_PR_YIELD,
TK_PR_SIGNAL,
TK_PR_BREAKPOINT,
TK_PR_REMOTE,
TK_PR_SYNC,
TK_PR_MASTER,
TK_PR_SLAVE,
TK_BRACKET_OPEN,
TK_BRACKET_CLOSE,
TK_CURLY_BRACKET_OPEN,