private void Start()
{
state = InteractiveState.Default;
levelManager = LevelManager.instance;
waveManager = WaveManager.instance;
// Activate UI.
gameoverUI.SetActive(false);
winUI.SetActive(false);
optionUI.SetActive(false);
towerOptionUI.SetActive(false);
towerInfoUI.SetActive(false);
waveProgressUI.SetActive(false);
// Subscribe event.
levelManager.moneyUpdated += OnMoneyUpdated;
levelManager.lifeUpdated += OnLifeUpdated;
levelManager.gameWin += OnGameWin;
levelManager.gameover += OnGameOver;
// Initialize info text.
moneyText.text = levelManager.money + "";
lifeText.text = levelManager.life + "";
}
// 캐릭터 스킬 사용 여부 체크
private void Update()
{
// 본인이라면
if (photonView.isMine)
{
// 상호작용이 가능하다면
if (findObject.GetIsInteraction())
{
// 상태를 살핀다.
if (CheckState())
{
// 키 눌렀는지 판단한다.
if (CheckInterKey())
{
// 1. 상호작용 물체 등록
interactiveObject = findObject.GetObjectTarget();
interactiveState = interactiveObject.GetComponent <InteractiveState>();
// 2. 상호작용 탐지 해제
findObject.SetisUseFindObject(false);
// 3. 상호작용 설정 디폴트로 변경
findObject.BackDefault();
// 4. 카메라 설정 변경
playerCamera.SetCameraRadX(-transform.eulerAngles.y);
playerCamera.SetCameraModeType(PlayerCamera.EnumCameraMode.FREE);
// 5. 타임 바 기본으로 설정
BaseTimeBarScript();
// 6. 상태 NONE 으로 변경
playerState.SetPlayerCondition(PlayerState.ConditionEnum.NONE);
// 스피드 0으로 설정
boxPlayerMove.SetVSpeed(0.0f);
boxPlayerMove.SetHSpeed(0.0f);
// 애니메이션 블렌드 위치 0 으로 설정
animator.SetFloat("DirectionX", 0);
animator.SetFloat("DirectionY", 0);
// 7. 전송
interactiveState.CallInterMessage(photonView.viewID, this);
// 8. ViewID 동기화
// 애니메이션 동기화하고 viewID 동기화시간이 다름, 최대 0.1초
interViewID = interactiveObject.GetPhotonView().viewID;
// 9. 플레이어 카메라 위치 저장, 동기화
OriginalCameraPosition = playerCamera.transform.position;
}
}
}
}
}
public void ReturnGame()
{
state = InteractiveState.Default;
if (optionUI.activeSelf)
{
optionUI.SetActive(false);
}
Time.timeScale = 1;
}
private IEnumerator setStateOfButtonsDelayed(InteractiveState state)
{
for (int i = 0; i < 10; i++)
{
yield return(null);
}
friendsButton.interactable = state == InteractiveState.Interactive;
popularButton.interactable = state == InteractiveState.Interactive;
}
private void OnBuildFinished()
{
if (currentBuildingTower != null)
{
state = InteractiveState.Default;
currentBuildingTower = null;
towerInfoUI.SetActive(false);
towerOptionUI.SetActive(false);
}
}
bool HaveInteraction(InteractiveState IS)
{
for (int i = 0; i < Inters.Count; i++)
{
if (Inters[i].InterScript == IS)
{
return(true);
}
}
return(false);
}
private void OnTriggerStay(Collider other)
{
// 상호작용 인 경우
if (other.tag == "Interaction")
{
// 해당 스크립트를 받아옵니다.
InteractiveState IS = other.gameObject.GetComponent <InteractiveState>();
// 충돌물체가 viewid와 같다면 &&
// 본인이 소유한게 아니라면 &&
// 문제점 :
//
if ((newInteractionSkill.GetinterViewID() == IS.photonView.viewID) &&
(!newInteractionSkill.photonView.isMine))
{
Debug.Log("asdF");
// 물체 등록
newInteractionSkill.SetinteractiveObject(other.gameObject);
newInteractionSkill.SetinteractiveState(IS);
}
// 사용 불가능하면
if (!IS.GetCanUseObject())
{
// 리스트에 없다면
if (!HaveInteraction(IS))
{
MeshRenderer mr = IS.gameObject.GetComponent <MeshRenderer>();
// 기존 원래 재질을 받아옵니다.
Material mt = mr.material;
// 새 재질을 적용시킵니다.
mr.material = HideMaterial;
// 구조체화 시키기
StructInteraction SI = new StructInteraction();
SI.InterScript = IS;
SI.OriginalMaterial = mt;
SI.meshRenderer = mr;
Debug.Log("@1422151'");
// 리스트를 추가합니다.
Inters.Add(SI);
}
}
}
}
private InteractiveTypeSpec ParseType(string[] cmd, ref int idx, InteractiveState state = null)
{
if (state == null)
{
state = s;
}
if (idx >= cmd.Length || cmd[idx] == ":")
{
return(state.ts);
}
var tname = cmd[idx++];
InteractiveTypeSpec new_ts = null;
if (state.m.AllTypes.ContainsKey(tname))
{
new_ts = state.m.AllTypes[tname];
}
else if (corlib.AllTypes.ContainsKey(tname))
{
new_ts = corlib.AllTypes[tname];
}
if (new_ts == null)
{
Console.WriteLine("Type: " + tname + " not found in " + state.m.m.AssemblyName);
return(state.ts);
}
if (idx < cmd.Length)
{
if (cmd[idx] == "<")
{
// handle generics
idx++;
var gtparams = new List <TypeSpec>();
while (cmd[idx] != ">")
{
gtparams.Add(ParseType(cmd, ref idx, state));
if (cmd[idx] == ",")
{
idx++;
}
}
idx++;
new_ts.ts.gtparams = gtparams.ToArray();
}
}
return(new_ts);
}
private void setStateOfSelectionButtons(InteractiveState state)
{
switch (state)
{
case InteractiveState.Interactive:
pooledScrollRect.IsScrollingAllowed = true;
StartCoroutine(setStateOfButtonsDelayed(state));
break;
case InteractiveState.NonInteractive:
friendsButton.interactable = false;
popularButton.interactable = false;
pooledScrollRect.IsScrollingAllowed = false;
break;
}
}
private static InteractiveState LoadInteractiveState(BinaryReader reader)
{
var state = new InteractiveState
{
IsInside = reader.ReadBoolean(),
IsPressed = reader.ReadBoolean(),
IsSelected = reader.ReadBoolean(),
RelativePointerPosition = new Vector2D(reader.ReadSingle(), reader.ReadSingle()),
CanHaveFocus = reader.ReadBoolean(),
HasFocus = reader.ReadBoolean(),
WantsFocus = reader.ReadBoolean(),
DragStart = new Vector2D(reader.ReadSingle(), reader.ReadSingle()),
DragEnd = new Vector2D(reader.ReadSingle(), reader.ReadSingle()),
DragDone = reader.ReadBoolean()
};
return(state);
}
private List <string> GetContext(string context_text)
{
context_text = context_text.Trim();
if (context_text == string.Empty)
{
return(i.cmds);
}
var ctx = Tokenize(context_text, Separators);
int idx = 0;
var state = new InteractiveState {
m = i.s.m, ms = i.s.ms, ts = i.s.ts
};
return(ParseCommandForOptions(ctx, ref idx, state));
throw new NotImplementedException();
}
private List <string> ParseCommandForOptions(List <string> ctx, ref int idx, InteractiveState state)
{
var cmd = ctx[idx++];
if (cmd == "select.type")
{
return(ParseTypeForOptions(ctx, ref idx, state));
}
else if (cmd == "select.module")
{
return(ParseModuleForOptions2(ctx, ref idx, state));
}
if (cmd == "implement.interface")
{
return(ParseInterfaceForOptions(ctx, ref idx, state));
}
else if (cmd == "select.method")
{
return(ParseMethodForOptions(ctx, ref idx, state));
}
else if (cmd == "assemble.method")
{
if (idx < ctx.Count || state.ms == null)
{
return(ParseMethodForOptions(ctx, ref idx, state));
}
else
{
return(new List <string>());
}
}
else if (cmd == "list.methods" || cmd == "list.interfaces" || cmd == "list.vmethods" || cmd == "list.fields")
{
if (idx < ctx.Count || state.ts == null)
{
return(ParseTypeForOptions(ctx, ref idx, state));
}
else
{
return(new List <string>());
}
}
return(new List <string>());
throw new NotImplementedException();
}
public void Pause()
{
state = InteractiveState.NonInteractive;
Time.timeScale = 0;
}
internal bool DoInteractive()
{
ach = new AutoCompleteHandler(this);
ReadLine.AutoCompletionHandler = ach;
ReadLine.HistoryEnabled = true;
while (true)
{
dump_state();
string[] cmd;
while ((cmd = get_command()).Length == 0)
{
;
}
// handle the command
int idx = 0;
if (cmd[idx] == "select.type")
{
idx++;
s.m = ParseModule(cmd, ref idx);
s.ts = ParseType(cmd, ref idx);
s.ts = instantiate_type(s.ts);
}
else if (cmd[idx] == "select.method")
{
idx++;
s.m = ParseModule(cmd, ref idx);
s.ts = ParseType(cmd, ref idx);
s.ms = ParseMethod(cmd, ref idx);
}
else if (cmd[idx] == "select.module")
{
idx++;
s.m = ParseModule2(cmd, ref idx);
}
else if (cmd[idx] == "quit" || cmd[idx] == "q")
{
return(false);
}
else if (cmd[idx] == "continue" || cmd[idx] == "c")
{
return(true);
}
else if (cmd[idx] == "assemble.method")
{
idx++;
s.m = ParseModule(cmd, ref idx);
s.ts = ParseType(cmd, ref idx);
s.ms = ParseMethod(cmd, ref idx);
t.InitIntcalls();
tst.r = new libtysila5.CachingRequestor(s.m.m);
tst.st = new libtysila5.StringTable("Interactive", s.ms.ms.m.al, Program.t);
StringBuilder sb = new StringBuilder();
libtysila5.libtysila.AssembleMethod(s.ms.ms, new binary_library.binary.FlatBinaryFile(), t, tst, sb);
Console.WriteLine(sb.ToString());
}
else if (cmd[idx] == "list.methods")
{
idx++;
s.m = ParseModule(cmd, ref idx);
s.ts = ParseType(cmd, ref idx);
foreach (var meth in s.ts.AllMethods.Keys)
{
Console.WriteLine(meth);
}
}
else if (cmd[idx] == "list.fields")
{
idx++;
s.m = ParseModule(cmd, ref idx);
s.ts = ParseType(cmd, ref idx);
foreach (var fld in s.ts.AllFields.Keys)
{
Console.WriteLine(s.ts.AllFields[fld].ToString());
}
Console.WriteLine(" Total size: " + s.ts.TypeSize.ToString("X"));
}
else if (cmd[idx] == "list.vmethods")
{
idx++;
s.m = ParseModule(cmd, ref idx);
s.ts = ParseType(cmd, ref idx);
var vmeths = libtysila5.layout.Layout.GetVirtualMethodDeclarations(s.ts);
libtysila5.layout.Layout.ImplementVirtualMethods(s.ts, vmeths);
foreach (var vmeth in vmeths)
{
var impl_ms = vmeth.impl_meth;
string impl_target = (impl_ms == null) ? "__cxa_pure_virtual" : impl_ms.MethodReferenceAlias;
var ims = new InteractiveMethodSpec(vmeth.unimpl_meth);
Console.WriteLine(ims.Name + " -> " + impl_target);
}
}
else if (cmd[idx] == "list.interfaces")
{
idx++;
s.m = ParseModule(cmd, ref idx);
s.ts = ParseType(cmd, ref idx);
foreach (var ii in s.ts.ts.ImplementedInterfaces)
{
Console.WriteLine(((InteractiveTypeSpec)ii).Name);
}
}
else if (cmd[idx] == "implement.interface")
{
idx++;
InteractiveState istate = new InteractiveState();
istate.m = ParseModule(cmd, ref idx);
istate.ts = ParseType(cmd, ref idx, istate);
t.InitIntcalls();
tst.r = new libtysila5.CachingRequestor(s.m.m);
var iis = libtysila5.layout.Layout.ImplementInterface(s.ts, istate.ts, t, tst);
foreach (var ii in iis)
{
Console.WriteLine(((InteractiveMethodSpec)ii.InterfaceMethod).Name + " -> " + ii.TargetName);
}
}
else
{
Console.WriteLine("Unknown command: " + cmd[idx]);
}
}
throw new NotImplementedException();
return(false);
}
private List <string> ParseModuleForOptions(List <string> ctx, ref int idx, InteractiveState state)
{
if (idx >= ctx.Count)
{
// end of the parse, return all loaded modules
return(new List <string>(state.m.m.al.LoadedAssemblies));
}
// else, make the new module our current scope
var mod_list = new List <string>(state.m.m.al.LoadedAssemblies);
var new_mod = ctx[idx++];
if (mod_list.Contains(new_mod))
{
var new_m = new InteractiveMetadataStream {
m = state.m.m.al.GetAssembly(new_mod)
};
state.m = new_m;
}
if (idx++ >= ctx.Count)
{
// must terminate a module with closing bracket
return(new List <string> {
"]"
});
}
return(ParseTypeForOptions(ctx, ref idx, state));
}
private List <string> ParseModuleForOptions2(List <string> ctx, ref int idx, InteractiveState state)
{
return(new List <string>(state.m.m.al.LoadedAssemblies));
}
private List <string> ParseTypeForOptions(List <string> ctx, ref int idx, InteractiveState state)
{
if (idx >= ctx.Count)
{
// no types listed, return all in the current module
return(new List <string>(state.m.AllTypes.Keys));
}
if (ctx[idx] == "[")
{
idx++;
var ret = ParseModuleForOptions(ctx, ref idx, state);
if (ret != null)
{
return(ret);
}
}
if (state.m.AllTypes.ContainsKey(ctx[idx]))
{
state.ts = state.m.AllTypes[ctx[idx++]];
}
return(null);
}
public void SetObjectState(InteractiveState IS)
{
ObjectState = IS;
}
public void SetinteractiveState(InteractiveState IS)
{
interactiveState = IS;
}
private List <string> ParseInterfaceForOptions(List <string> ctx, ref int idx, InteractiveState state)
{
if (idx >= ctx.Count && state.ts != null)
{
var ret = new List <string>();
foreach (var ii in state.ts.ts.ImplementedInterfaces)
{
ret.Add(((InteractiveTypeSpec)ii).Name);
}
return(ret);
}
return(new List <string>());
}
private void MakeStateManager()
{
RoutineState routine = new RoutineState(player, gameObject);
routine.AddTransition(Transition.PlayerLearning, StateID.InteractiveStateID);
InteractiveState interactive = new InteractiveState(player, gameObject);
interactive.AddTransition(Transition.SetPlayerTask, StateID.WaitingStateID);
WaitingState waiting = new WaitingState(player, gameObject);
waiting.AddTransition(Transition.PlayerTaskComplete, StateID.EndStateID);
EndState end = new EndState(player, gameObject);
end.AddTransition(Transition.AllDone, StateID.RoutineStateID);
manager = new NPCStateManager();
manager.AddState(routine);
manager.AddState(interactive);
manager.AddState(waiting);
manager.AddState(end);
}
private List <string> ParseMethodForOptions(List <string> ctx, ref int idx, InteractiveState state)
{
// methods may be described by name or type:name
var ret = ParseTypeForOptions(ctx, ref idx, state);
if (ret == null)
{
ret = new List <string>();
}
if (idx < ctx.Count && ctx[idx] == ":")
{
idx++;
}
if (idx >= ctx.Count && state.ts != null)
{
ret.AddRange(state.ts.AllMethods.Keys);
}
return(ret);
}
