void ParseBuildInFunction(OperationCode opcode, int param_count)
{
GetToken();
if (m_token_type != TokenType.LEFT_PAREN)
{
LogWrapper.LogError("Expression: ParseBuildInFunction, '(' expected");
}
if (param_count > 0)
{
GetToken();
ParseExpression();
--param_count;
while (param_count > 0)
{
if (m_token_type != TokenType.COMMA)
{
m_error_occurred = true;
LogWrapper.LogError("Expression: ParseBuildInFunction, ',' expected");
return;
}
GetToken();
ParseExpression();
--param_count;
}
}
if (m_token_type != TokenType.RIGHT_PAREN)
{
m_error_occurred = true;
LogWrapper.LogError("Expression: ParseBuildInFunction, ')' expected");
return;
}
AppendOperation(opcode);
GetToken();
}
public static void RegisterVariable(int variable_id, int component_type_id)
{
#if UNITY_EDITOR
if (m_variable2component.ContainsKey(variable_id))
{
LogWrapper.LogError("ComponentTypeRegistry, variable id(", (uint)variable_id, ") has already existed.");
}
#endif
m_variable2component[variable_id] = component_type_id;
}
public static void RegisterAttribute(AttributeData data)
{
#if UNITY_EDITOR
string existed_name;
if (ms_all_ids.TryGetValue(data.m_attribute_id, out existed_name))
{
LogWrapper.LogError("AttributeSystem, attribute ", data.m_attribute_name, " has same crcid with existed attribute ", existed_name);
}
#endif
ms_all_ids[data.m_attribute_id] = data.m_attribute_name;
}
protected override void OnSceneWasLoaded()
{
GameObject camera_go = GameObject.Find("GameGlobal/GameMainCamera/Camera");
if (camera_go == null)
{
LogWrapper.LogError("RenderWorld.LoadScene, GameGlobal/GameMainCamera/Camera");
}
else
{
m_camera_controller.SetCameraUnityObject(camera_go);
}
}
void ParseTerm()
{
ParseFactor();
while (true)
{
OperationCode op_code = OperationCode.END;
switch (m_token_type)
{
case TokenType.STAR:
op_code = OperationCode.MULTIPLY;
break;
case TokenType.SLASH:
op_code = OperationCode.DIVIDE;
break;
case TokenType.AND:
op_code = OperationCode.AND;
break;
case TokenType.AND_BITWISE:
op_code = OperationCode.AND_BITWISE;
break;
default:
break;
}
if (op_code == OperationCode.END)
{
break;
}
GetToken();
ParseFactor();
AppendOperation(op_code);
}
if (m_token_type == TokenType.QUESTION)
{
GetToken();
ParseFactor();
if (m_token_type != TokenType.SEMICOLON)
{
LogWrapper.LogError("Expression: ParseTerm(), TokenType.SEMICOLON expected");
}
GetToken();
ParseFactor();
AppendOperation(OperationCode.CONDITIONAL_EXPRESSION);
}
}
public void ExitAllAction()
{
var enumerator = m_previous_actions.GetEnumerator();
while (enumerator.MoveNext())
{
enumerator.Current.ExitAction();
}
m_previous_actions.Clear();
if (m_current_actions.Count > 0)
{
LogWrapper.LogError("BTActionBuffer::ExitAllAction(), m_current_actions isn't empty");
}
m_current_actions.Clear();
}
public bool UpdatePosition()
{
if (m_unity_go == null)
{
LogWrapper.LogError("ModelComponent.UpdatePosition, Object has already been destroyed！！！！！！！！！");
return(false); //ZZWTODO
}
m_last_position = RenderWorld.Vector3FP_To_Vector3(m_position_component.CurrentPosition);
if (m_predict_component != null)
{
m_predict_component.OnLogicUpdatePosition(m_last_position - m_bodyctrl_tr.localPosition);
}
m_bodyctrl_tr.localPosition = m_last_position;
return(true);
}
public void Restore()
{
if (m_previous_actions.Count > 0)
{
LogWrapper.LogError("BTActionBuffer::Restore(), m_previous_actions isn't empty");
}
if (m_current_actions.Count > 0)
{
LogWrapper.LogError("BTActionBuffer::Restore(), m_current_actions isn't empty");
}
List <BTAction> temp = m_backup_previous_action;
m_backup_previous_action = m_previous_actions;
m_previous_actions = temp;
}
public virtual void LoadScene(string scene_name)
{
Scene scene = SceneManager.GetSceneByPath(scene_name);
if (scene == null)
{
LogWrapper.LogError("MyRenderWorld LoadScene(), ", scene_name);
return;
}
m_loading_scenes.Add(scene_name);
if (m_loading_scenes.Count == 1)
{
SceneManager.sceneLoaded += SceneLoadedCallback;
}
SceneManager.LoadScene(scene_name);
}
public static void Register(System.Type type)
{
int btnode_type_id = (int)CRC.Calculate(type.Name);
#if UNITY_EDITOR
System.Type existed_type;
if (m_btnodes_id2type.TryGetValue(btnode_type_id, out existed_type))
{
if (type.Name != existed_type.Name)
{
LogWrapper.LogError("BehaviorTreeNodeTypeRegistry, BTNode ", type.FullName, " has same crcid with existed BTNode ", existed_type.FullName);
}
}
#endif
m_btnodes_id2type[btnode_type_id] = type;
m_btnodes_type2id[type] = btnode_type_id;
}
void InitializeSyncModelTest()
{
string expression = "(2 > 3) ? (2 + 5) : (1 + 2)";
Combat.ExpressionProgram program = new Combat.ExpressionProgram();
program.Compile(expression);
FixPoint result = program.Evaluate(null);
LogWrapper.LogError(expression, ", EVALUATES ", result);
if (m_combat_tester != null)
{
return;
}
//m_sync_tester = new Combat.SyncTester(this);
//m_sync_tester.Init();
m_combat_tester = new Combat.CombatTester();
m_combat_tester.Initialize();
}
public static void Register(System.Type type, bool is_render_componet)
{
int component_type_id = (int)CRC.Calculate(type.Name);
#if UNITY_EDITOR
System.Type existed_type;
if (m_components_id2type.TryGetValue(component_type_id, out existed_type))
{
if (type.Name != existed_type.Name)
{
LogWrapper.LogError("ComponentTypeRegistry, component ", type.FullName, " has same crcid with existed component ", existed_type.FullName);
}
}
#endif
m_components_id2type[component_type_id] = type;
m_components_type2id[type] = component_type_id;
if (is_render_componet)
{
m_render_components_id.Add(component_type_id);
}
}
BehaviorTreeCache GetPool(int bt_config_id, out bool is_new)
{
is_new = false;
BehaviorTreeCache pool = null;
if (!m_pools.TryGetValue(bt_config_id, out pool))
{
is_new = true;
pool = new BehaviorTreeCache();
BehaviorTree instance = CreateBeahviorTreeFromConfig(bt_config_id);
if (instance == null)
{
LogWrapper.LogError("BehaviorTreeFactory, INVALID ID, ", bt_config_id);
}
else
{
pool.m_proto = instance;
pool.m_cache.Add(instance);
}
m_pools[bt_config_id] = pool;
}
return(pool);
}
char SkipWhiteSpace()
{
while (!m_text_buffer.Eof())
{
char code = Tokenizer.GetCode(m_text_buffer.Char());
switch (code)
{
case WhiteSpace:
break;
case Error:
m_error = true;
LogWrapper.LogError("Expression: Tokenizer.SkipWhiteSpace(), illegal character in the buffer, index = ", m_text_buffer.CurrentIndex, ", char = ", m_text_buffer.Char());
return(code);
default:
return(code);
}
m_text_buffer.NextChar();
}
RecyclableObject.Recycle(m_text_buffer);
m_text_buffer = null;
return(Eof);
}
void Print(string str)
{
LogWrapper.LogError(str);
}
void ConfirmEntityMove(EntityMoveCommand cmd, bool result)
{
switch (cmd.m_move_type)
{
case EntityMoveCommand.DirectionType:
{
uint crc = CalculateMoveCommandCRC(cmd);
//LogWrapper.LogDebug("ConfirmEntityMove, DirectionType, time =", GetCurrentTime(), ", crc = ", crc);
for (int i = 0; i < m_movement_predicts.Count;)
{
MovementPredict predict = m_movement_predicts[i];
if (predict.m_command_crc != crc)
{
m_accumulated_offset += predict.m_offset;
if (predict.m_state != MovementPredict.EliminateOffsetState)
{
LogWrapper.LogError("REMOVE UNCONFIRMED PREDICT ", predict.m_command_crc, ", predict.m_offset = ", predict.m_offset.ToString());
}
ResetOffsetDirection();
RecyclableObject.Recycle(predict);
m_movement_predicts.RemoveAt(i);
continue;
}
else
{
if (predict.m_state == MovementPredict.AccumulateOffsetState)
{
predict.m_state = MovementPredict.FollowLogicState;
predict.m_task.ResetMaxPredictTime(GetRenderWorld().CurrentTime, m_follow_logic_predict_time);
}
break;
}
}
}
break;
case EntityMoveCommand.DestinationType:
{
if (m_copy_state == WaitCopy)
{
m_copy_state = DoCopy;
}
if (!result && m_copy_state == DoCopy)
{
StopMoveAnimation();
}
//下面这段代码和EntityMoveCommand.StopMoving差不多
for (int i = 0; i < m_movement_predicts.Count;)
{
MovementPredict predict = m_movement_predicts[i];
if (predict.m_state != MovementPredict.CopyLogicState)
{
m_accumulated_offset += predict.m_offset;
if (predict.m_state != MovementPredict.EliminateOffsetState)
{
LogWrapper.LogError("REMOVE UNCONFIRMED PREDICT ", predict.m_command_crc, ", predict.m_offset = ", predict.m_offset.ToString());
}
ResetOffsetDirection();
RecyclableObject.Recycle(predict);
m_movement_predicts.RemoveAt(i);
continue;
}
else
{
m_movement_predicts.RemoveAt(i);
break;
}
}
if (m_movement_predicts.Count == 0)
{
//LogWrapper.LogDebug("ConfirmEntityMove, BEFOREE SET offset = ", m_accumulated_offset.ToString());
m_accumulated_offset = m_interpolation_tr.localPosition;
ResetOffsetDirection();
//LogWrapper.LogDebug("ConfirmEntityMove, all stoped, m_accumulated_offset = ", m_accumulated_offset.ToString());
}
}
break;
case EntityMoveCommand.StopMoving:
{
//LogWrapper.LogDebug("ConfirmEntityMove, STOP, time = ", GetCurrentTime());
for (int i = 0; i < m_movement_predicts.Count;)
{
MovementPredict predict = m_movement_predicts[i];
if (predict.m_state != MovementPredict.StopState)
{
m_accumulated_offset += predict.m_offset;
if (predict.m_state != MovementPredict.EliminateOffsetState)
{
LogWrapper.LogError("REMOVE UNCONFIRMED PREDICT ", predict.m_command_crc, ", predict.m_offset = ", predict.m_offset.ToString());
}
ResetOffsetDirection();
RecyclableObject.Recycle(predict);
m_movement_predicts.RemoveAt(i);
continue;
}
else
{
m_movement_predicts.RemoveAt(i);
break;
}
}
if (m_movement_predicts.Count == 0)
{
//LogWrapper.LogDebug("ConfirmEntityMove, BEFOREE SET offset = ", m_accumulated_offset.ToString());
m_accumulated_offset = m_interpolation_tr.localPosition;
ResetOffsetDirection();
//LogWrapper.LogDebug("ConfirmEntityMove, all stoped, m_accumulated_offset = ", m_accumulated_offset.ToString());
}
}
break;
default:
break;
}
}
void ParseFactor()
{
switch (m_token_type)
{
case TokenType.NUMBER:
AppendNumber(m_token.GetNumber());
GetToken();
break;
case TokenType.LEFT_PAREN:
GetToken();
ParseExpression();
if (m_token_type != TokenType.RIGHT_PAREN)
{
m_error_occurred = true;
LogWrapper.LogError("Expression: ParseFactor(), ')' expected");
return;
}
GetToken();
break;
case TokenType.IDENTIFIER:
m_raw_variable.Clear();
m_raw_variable.Add(m_token.GetRawString());
GetToken();
while (m_token_type == TokenType.PERIOD)
{
GetToken();
if (m_token_type != TokenType.IDENTIFIER)
{
m_error_occurred = true;
LogWrapper.LogError("Expression: ParseFactor(), TokenType.Identifier expected");
return;
}
m_raw_variable.Add(m_token.GetRawString());
GetToken();
}
AppendVariable(m_raw_variable);
m_raw_variable.Clear();
break;
case TokenType.NOT:
GetToken();
ParseFactor();
AppendOperation(OperationCode.NOT);
break;
case TokenType.SINE:
ParseBuildInFunction(OperationCode.SIN, 1);
break;
case TokenType.COSINE:
ParseBuildInFunction(OperationCode.COS, 1);
break;
case TokenType.TANGENT:
ParseBuildInFunction(OperationCode.TAN, 1);
break;
case TokenType.SQUARE_ROOT:
ParseBuildInFunction(OperationCode.SQRT, 1);
break;
case TokenType.MINIMUM:
ParseBuildInFunction(OperationCode.MIN, 2);
break;
case TokenType.MAXIMUM:
ParseBuildInFunction(OperationCode.MAX, 2);
break;
case TokenType.CLAMP:
ParseBuildInFunction(OperationCode.CLAMP, 3);
break;
default:
break;
}
}
public override bool Get(TextBuffer text_buffer)
{
char ch = text_buffer.Char();
switch (ch)
{
case '+':
m_type = TokenType.PLUS;
text_buffer.NextChar();
break;
case '-':
m_type = TokenType.MINUS;
text_buffer.NextChar();
break;
case '*':
m_type = TokenType.STAR;
text_buffer.NextChar();
break;
case '/':
m_type = TokenType.SLASH;
text_buffer.NextChar();
break;
case '(':
m_type = TokenType.LEFT_PAREN;
text_buffer.NextChar();
break;
case ')':
m_type = TokenType.RIGHT_PAREN;
text_buffer.NextChar();
break;
case '[':
m_type = TokenType.LEFT_BRACKET;
text_buffer.NextChar();
break;
case ']':
m_type = TokenType.RIGHT_BRACKET;
text_buffer.NextChar();
break;
case '.':
m_type = TokenType.PERIOD;
text_buffer.NextChar();
break;
case ',':
m_type = TokenType.COMMA;
text_buffer.NextChar();
break;
case '?':
m_type = TokenType.QUESTION;
text_buffer.NextChar();
break;
case ':':
m_type = TokenType.SEMICOLON;
text_buffer.NextChar();
break;
case '=':
m_type = TokenType.EQUAL;
ch = text_buffer.NextChar();
if (ch == '=')
{
m_type = TokenType.EQUAL_EQUAL;
text_buffer.NextChar();
}
break;
case '!':
m_type = TokenType.NOT;
ch = text_buffer.NextChar();
if (ch == '=')
{
m_type = TokenType.NOT_EQUAL;
text_buffer.NextChar();
}
break;
case '>':
m_type = TokenType.GREATER;
ch = text_buffer.NextChar();
if (ch == '=')
{
m_type = TokenType.GREATER_EQUAL;
text_buffer.NextChar();
}
break;
case '<':
m_type = TokenType.LESS;
ch = text_buffer.NextChar();
if (ch == '=')
{
m_type = TokenType.LESS_EQUAL;
text_buffer.NextChar();
}
break;
case '&':
m_type = TokenType.AND_BITWISE;
ch = text_buffer.NextChar();
if (ch == '&')
{
m_type = TokenType.AND;
text_buffer.NextChar();
}
break;
case '|':
m_type = TokenType.OR_BITWISE;
ch = text_buffer.NextChar();
if (ch == '|')
{
m_type = TokenType.OR;
text_buffer.NextChar();
}
break;
default:
LogWrapper.LogError("Expression: SymbolToken.Get(), illegal symbol, index = ", text_buffer.CurrentIndex, ", char = ", text_buffer.Char());
m_type = TokenType.ERROR;
return(false);
}
return(true);
}
