private void Awake()
{
_navMeshAgent = GetComponent <NavMeshAgent>();
_animator = GetComponent <Animator>();
_rigShooting = GetComponentInChildren <Rig>();
_rigShooting.weight = 0;
_detection = Instantiate(_detection);
_detection.Character = this;
_detection.Init();
}
public void ChangeState(State newState)
{
if (newState == currentState)
{
return;
}
currentState = newState;
currentState.Init();
}
// 初期化
public void InitializeState(State state)
{
// インスタンスセット
state.SetUnitInstance(unit);
state.SetAnimatorObj(animator);
state.SetEffectCreater(effect);
state.Init();
current_state = state;
}
public void ChangeState(States state)
{
// Debug.Log("Change State");
if (m_CurState!=null)
{
m_CurState.Exit();
}
m_CurState = m_States[(int)state];
m_CurState.Init();
}
private void SetupServices()
{
State.Init();
var services = new ServiceCollection();
services.AddCorrelationAccessor();
AddMessageConsumer(services);
_serviceProvider = services.BuildServiceProvider();
}
void Start()
{
movers = FindObjectsOfType <Mover>();
State.Init();
foreach (Mover mover in movers)
{
State.AddMover(mover);
}
State.AddToUndoStack();
isMoving = false;
}
/// <summary>
/// intializes and adds a State to states. uses the State's name as a string, so a State named RunAway is
/// automatically stored with the key "RunAway". If this is the first State being added it automatically
/// pusshes state to curState
/// </summary>
/// <param name="state"></param>
public void AddState(State state)
{
state.Init(owner);
if (states.Count < 1)
{
curState.Push(state);
curState.Peek().Enter();
}
states.Add(state.ToString(), state);
}
// 状態遷移
public void ChangeState(State next_state)
{
// 現在の状態の終了
current_state.Exit();
// 次の状態へ遷移する準備
next_state.SetUnitInstance(unit);
next_state.SetEffectCreater(effect);
next_state.SetAnimatorObj(animator);
next_state.Init();
current_state = next_state;
}
public void SwitchState(State changeTo)
{
//Destroy the Current State
if(activeState!= null)
activeState.Destroy();
//Setup new State
activeState = changeTo;
Debugger.Debug_Log("Initializing State-" + changeTo.GetType().Name);
activeState.Init(_game, playerController);
}
public void ReplaceState(eStateType changeType, State replaceState)
{
if (_stateMap.ContainsKey(changeType))
{
_stateMap.Remove(changeType);
}
State state = replaceState;
state.Init(this);
_stateMap[changeType] = state;
}
// Production
// Rules database
void InitRules()
{
// Define Actions
runAwayAction.Init(actions.kRunAway, move);
evadeAction.Init(actions.kEvade, move);
goBackAction.Init(actions.kGoBack, move);
informAction.Init(actions.kInform, move);
wanderAction.Init(actions.kWander, move);
// Define States
onlySeeState.Init(enemyStates.kOnlySee, runAwayAction, 0.3f);
onlyHearState.Init(enemyStates.kOnlyHear, evadeAction, 0.3f);
seeAndHearState.Init(enemyStates.kSeeAndHear, goBackAction, 0.4f);
seeAndHearAndInformState.Init(enemyStates.kSeeAndHearAndInform, informAction, 0.2f);
informedState.Init(enemyStates.kInformed, goBackAction, 0.7f);
nothingState.Init(enemyStates.kNothing, wanderAction, 0.1f);
}
internal static void Init()
{
switch (Platform.GraphicsBackend)
{
#if VULKAN
case GraphicsBackend.Vulkan:
throw new NotImplementedException("Vulkan Graphics Backend not implemented yet.");
#endif
#if OPENGL
case GraphicsBackend.OpenGL:
#endif
#if OPENGLES
case GraphicsBackend.OpenGLES:
#endif
#if OPENGL || OPENGLES
graphics = new OpenGL.OpenGLGraphics();
break;
#endif
#if WEBGL
case GraphicsBackend.WebGL2:
graphics = new WebGL2.WebGL2Graphics();
break;
case GraphicsBackend.WebGL:
graphics = new WebGL.WebGLGraphics();
break;
#endif
default:
throw new NotSupportedException($"GraphicsBackend {Platform.GraphicsBackend} not supported.");
}
graphics.Init();
State.Init();
#if !WEBGL // Temporary
Platform.Events.OnWinResized += () =>
{
SetViewport();
SetScissorTest();
};
#endif // Temporary
// Debug
Output.WriteLine($"Graphics Initialized");
}
public override void BeforeTableExecute(FormatterTableHelper helper)
{
//one dict name, one state
var key = GetKey(helper.CurrentTable.TableName, Name);
if (helper.Session.ContainsKey(key))
{
_state = (State)helper.Session[key];
}
else
{
_state = new State(Name);
_state.Init();
helper.Session[key] = _state;
}
_state.RegistField(Field);
}
private static State <ulong, Memo> FactImpl(ulong number)
{
if (number <= 1)
{
return(State <ulong, Memo> .Init(1));
}
var memoed = State <Option <ulong>, Memo> .GetS(memo => memo.GetValueOrNone(number));
var result = memoed.Fmap(res =>
res.Match(
someFunc: v => State <ulong, Memo> .Init(v),
noneFunc: () =>
from next in FactImpl(number - 1)
let r = number * next
from _ in State <ulong, Memo> .Update(m => DictUpdate(m, number, r))
select r)
);
return(result);
}
protected virtual void TransitionTo(State value)
{
if (_currentState == value || _inTransition)
{
return;
}
_inTransition = true;
if (_currentState != null)
{
_currentState.Exit();
}
_currentState = value;
if (_currentState != null)
{
_currentState.Init();
}
_inTransition = false;
}
public void OnEnable()
{
CurrentWindow = this;
SetupAnalytics();
Evaluator.Init(ref Evaluator);
State.Init(ref State);
string path = EditorGUIUtility.isProSkin ? DarkStylePath : LightStylePath;
rootVisualElement.styleSheets.Add(EditorGUIUtility.Load(path) as StyleSheet);
var windowResource = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(TemplatePath);
if (windowResource != null)
{
var root = windowResource.CloneTree();
rootVisualElement.Add(root);
root.StretchToParentSize();
}
}
public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
Int64 inSize, Int64 outSize)
{
Init(inStream, outStream);
State state = new State();
state.Init();
uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
UInt64 nowPos64 = 0;
UInt64 outSize64 = (UInt64)outSize;
if (nowPos64 < outSize64)
{
if (m_IsMatchDecoders[state.Index << kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)
throw new Exception();
state.UpdateChar();
byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
m_OutWindow.PutByte(b);
nowPos64++;
}
while (nowPos64 < outSize64)
{
// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
// while(nowPos64 < next)
{
uint posState = (uint)nowPos64 & m_PosStateMask;
if (m_IsMatchDecoders[(state.Index << kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
{
byte b;
byte prevByte = m_OutWindow.GetByte(0);
if (!state.IsCharState())
b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,
(uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));
else
b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);
m_OutWindow.PutByte(b);
state.UpdateChar();
nowPos64++;
}
else
{
uint len;
if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
{
if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
if (m_IsRep0LongDecoders[(state.Index << kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
{
state.UpdateShortRep();
m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));
nowPos64++;
continue;
}
}
else
{
UInt32 distance;
if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
distance = rep1;
}
else
{
if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
distance = rep2;
else
{
distance = rep3;
rep3 = rep2;
}
rep2 = rep1;
}
rep1 = rep0;
rep0 = distance;
}
len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + kMatchMinLen;
state.UpdateRep();
}
else
{
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
len = kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
state.UpdateMatch();
uint posSlot = m_PosSlotDecoder[GetLenToPosState(len)].Decode(m_RangeDecoder);
if (posSlot >= kStartPosModelIndex)
{
int numDirectBits = (int)((posSlot >> 1) - 1);
rep0 = ((2 | (posSlot & 1)) << numDirectBits);
if (posSlot < kEndPosModelIndex)
rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
else
{
rep0 += (m_RangeDecoder.DecodeDirectBits(
numDirectBits - kNumAlignBits) << kNumAlignBits);
rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
}
}
else
rep0 = posSlot;
}
if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck)
{
if (rep0 == 0xFFFFFFFF)
break;
}
m_OutWindow.CopyBlock(rep0, len);
nowPos64 += len;
}
}
}
m_OutWindow.Flush();
m_OutWindow.ReleaseStream();
m_RangeDecoder.ReleaseStream();
}
public void Code(Stream inStream, Stream outStream,
Int64 inSize, Int64 outSize)
{
Init(inStream, outStream);
var state = new State();
state.Init();
uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
UInt64 nowPos64 = 0;
var outSize64 = (UInt64)outSize;
if (nowPos64 < outSize64)
{
m_IsMatchDecoders[state.Index << kNumPosStatesBitsMax].Decode(m_RangeDecoder);
state.UpdateChar();
byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
m_OutWindow.PutByte(b);
nowPos64++;
}
while (nowPos64 < outSize64)
{
// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
// while(nowPos64 < next)
{
uint posState = (uint)nowPos64 & m_PosStateMask;
if (m_IsMatchDecoders[(state.Index << kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
{
byte b;
byte prevByte = m_OutWindow.GetByte(0);
if (!state.IsCharState())
{
b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,
(uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));
}
else
{
b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);
}
m_OutWindow.PutByte(b);
state.UpdateChar();
nowPos64++;
}
else
{
uint len;
if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
{
if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
if (m_IsRep0LongDecoders[(state.Index << kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
{
state.UpdateShortRep();
m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));
nowPos64++;
continue;
}
}
else
{
UInt32 distance;
if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
distance = rep1;
}
else
{
if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
{
distance = rep2;
}
else
{
distance = rep3;
rep3 = rep2;
}
rep2 = rep1;
}
rep1 = rep0;
rep0 = distance;
}
len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + kMatchMinLen;
state.UpdateRep();
}
else
{
rep3 = rep2;
rep2 = rep1;
rep1 = rep0;
len = kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
state.UpdateMatch();
uint posSlot = m_PosSlotDecoder[GetLenToPosState(len)].Decode(m_RangeDecoder);
if (posSlot >= kStartPosModelIndex)
{
var numDirectBits = (int)((posSlot >> 1) - 1);
rep0 = ((2 | (posSlot & 1)) << numDirectBits);
if (posSlot < kEndPosModelIndex)
{
rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
}
else
{
rep0 += (m_RangeDecoder.DecodeDirectBits(
numDirectBits - kNumAlignBits) << kNumAlignBits);
rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
}
}
else
{
rep0 = posSlot;
}
}
if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck)
{
if (rep0 == 0xFFFFFFFF)
{
break;
}
}
m_OutWindow.CopyBlock(rep0, len);
nowPos64 += len;
}
}
}
m_OutWindow.Flush();
m_OutWindow.ReleaseStream();
m_RangeDecoder.ReleaseStream();
}
public void NextState()
{
if (states.Count <= 0)
{
return;
}
string name = states[0];
states.RemoveAt(0);
if (tempState != null)
{
tempState.EndState();
}
if (name.StartsWith("dialog"))
{
string sheet = name.Split('-')[1];
DataTable table = helper.ReadSheet(sheet);
Debug.Log("dialog size" + table.rows.Count);
for (int i = 0; i < table.rows.Count; ++i)
{
string dialog2 = "";
if (table.Contains("Dialog2"))
{
dialog2 = table.rows[i].row.Select("Dialog2");
}
dialogFrame.addDialog(table.rows[i].row.Select("Character"), table.rows[i].row.Select("Dialog"), dialog2);
}
tempState = new DialogState();
tempState.Init(name);
if (name.EndsWith("room2"))
{
SecretaireClose.gameObject.SetActive(true);
}
else if (name.EndsWith("room3"))
{
SecretaireClose.gameObject.SetActive(false);
SecretaireOpen.gameObject.SetActive(true);
}
if (name.EndsWith("map"))
{
bigWhite.DOFade(0, 1f);
Map.gameObject.SetActive(true);
}
}
else if (name.StartsWith("track"))
{
tempState = new TrackState();
tempState.Init(name);
}
else if (name.StartsWith("begin"))
{
tempState = new BeginState();
tempState.Init(name);
}
else if (name.StartsWith("sec"))
{
tempState = new SecState();
tempState.Init(name);
}
else if (name.StartsWith("end"))
{
tempState = new EndState();
tempState.Init(name);
}
else if (name.StartsWith("delay"))
{
tempState = new DelayState();
tempState.Init(name);
float delay = float.Parse(name.Split('-')[1]);
StartCoroutine(DelayNextState(delay));
}
}
/// <summary>
/// Voeg een state toe aan de state machine
/// </summary>
/// <param name="stateId">Een integer die komt uit de ENUM StateID</param>
/// <param name="state">Een component die State.cs extend (inheritance)</param>
public void AddState(TStateId stateId, State <TStateId> state)
{
_states.Add(stateId, state);
state.enabled = false;
state.Init();
}
protected void StateInit(eState estate, State state)
{
state.Init(this);
_stateList.Add(estate, state);
}
public void SetState(State state)
{
currentState = Instantiate(state);
currentState.Character = this;
currentState.Init();
}
void Start()
{
currentState = new InitialState();
currentState.Init();
}
public void SetState(State state)
{
_currentStatePattern = Instantiate(state);
_currentStatePattern.unit = this;
_currentStatePattern.Init();
}
public void Initialize(State startingState)
{
currentState = startingState;
currentState.Init();
}
public State GetStateByName(string stateName)
{
// if ( stateName.Equals(Global.NOW_STATE))
// {
// return GetStateByName(machine.GetTempState().GetName());
// }
DataRow row = machine.GetMainRow(stateName);
State state;
if ( isFull(row,Global.TRANS_TO_COLUMN_NAME) )
{
state = new TransformState();
state.Init(row, stateName , machine);
return state;
}
else if ( isFull(row,Global.AUTO_NEXT_COLUMN_NAME))
{
if ( isFull(row,Global.DELAY_TIME_COLUMN_NAME) )
{
state = new NextTimeState();
state.Init(row, stateName , machine);
return state;
}else
{
state = new NextState();
state.Init(row,stateName,machine);
return state;
}
}
state = new State();
state.Init(row, stateName , machine);
return state;
}
public override void SetState(State state)
{
currentState = Instantiate(state);
currentState.character = this;
currentState.Init();
}
// 状態の変更
public void ChangeState(State state)
{
this.nextState = state;
nextState.Init(stateData);
}
Task InitStorageInterface()
{
table = new RedisEventTable(logger);
State.Init(EventName, table);
return(Task.CompletedTask);
}
internal TvDialog(ISkin skin, IViewport viewport, IComponentTree owner, string name = null)
: base(skin, viewport.Layer(ViewportLayer.Top, -1), new DialogState(skin, name ?? $"TvDialog_{Guid.NewGuid()}"))
{
Metadata.CanFocus = false;
State.Init(this, owner);
}
