protected override void Init()
{
RKLog.Log("Load prefab " + PrefabToLoad);
_canvas = GameObject.Find("Canvas").GetComponent <Canvas>();
HelperFunctions.GetPrefab2d(PrefabToLoad, _canvas.gameObject);
base.Init();
}
void Update()
{
if (_destroyed)
{
return;
}
if (_nrOfItems == 0)
{
RKLog.LogError("INFINITESCROLLER2 HEEFT GEEN DATA", "infinitescroller");
}
if (lastCount == 0 && _nrOfItems > 0)
{
Rebuild();
}
if (started)
{
fill();
}
if (_nrOfItems != 0)
{
lastCount = _nrOfItems;
}
}
private bool animate(States.State newstate, SceneAnimator.Animations animation = SceneAnimator.Animations.LEFT)
{
List <string> states2 = new List <string>();
States.State previousstate = GlobalController.StateManager.previous;
animation = SceneTransitionController.Instance.GetTransition(previousstate, newstate);
float time = SceneTransitionController.Instance.GetSpeed(previousstate, newstate);
bool ret = false;
RKLog.Log("change state from: " + previousstate + " to " + newstate);
if (_forceDirection != SceneAnimator.Animations.NONE)
{
animation = _forceDirection;
_forceDirection = SceneAnimator.Animations.NONE;
}
SceneAnimator.Instance.animateIn(SceneLoader.Instance.Scene(previousstate), SceneLoader.Instance.Scene(newstate), animation, time);
ret = true;
return(ret);
}
private void Init()
{
RKLog.Log("Init");
StateManager = new StateManager();
StateManager.stateChanged.AddListener(StateChanged);
_sceneController = SceneController.Instance;
}
public string GetParsedUrl(string url, GenericData replacements = null)
{
string baseurl = Config.GetURL() + url;
if (replacements != null)
{
foreach (KeyValuePair <string, int> keyval in replacements.Ints)
{
baseurl = baseurl.Replace("{" + keyval.Key + "}", keyval.Value.ToString());
RKLog.Log("replace {" + keyval.Key + "} with " + keyval.Value.ToString(), "apicontroller");
}
foreach (KeyValuePair <string, string> keyval in replacements.Strings)
{
baseurl = baseurl.Replace("{" + keyval.Key + "}", keyval.Value);
RKLog.Log("replace {" + keyval.Key + "} with " + keyval.Value.ToString(), "apicontroller");
}
foreach (KeyValuePair <string, float> keyval in replacements.Floats)
{
baseurl = baseurl.Replace("{" + keyval.Key + "}", keyval.Value.ToString());
RKLog.Log("replace {" + keyval.Key + "} with " + keyval.Value.ToString(), "apicontroller");
}
foreach (KeyValuePair <string, bool> keyval in replacements.Bools)
{
baseurl = baseurl.Replace("{" + keyval.Key + "}", keyval.Value.ToString());
RKLog.Log("replace {" + keyval.Key + "} with " + keyval.Value.ToString(), "apicontroller");
}
}
return(baseurl);
}
private void OnWebSocketOpen(WebSocket webSocket)
{
_connected = true;
_lastStateCounter = 0;
RKLog.Log("WebSocket is now Open!", "socketcontroller");
SetToken();
}
public void Init()
{
RKLog.Log("init scenecontroller");
RKLog.Log(GlobalController.StateManager.stateChanged.ToString());
GlobalController.StateManager.stateChanged.AddListener(stateChanged);
GlobalController.StateManager.stateAgain.AddListener(stateAgain);
SceneLoader.Instance.sceneloaded.AddListener(SceneLoaded);
}
private void Init()
{
RKLog.Log("init", "socketcontroller");
Connect();
InvokeRepeating("CheckState", 3.0f, 3.0f);
RKLog.Log("connect to " + Config.GetSocket(), "socketcontroller");
}
public void CheckStates()
{
if (WaitingStates.Count > 0)
{
RKLog.Log("Unlocked, check states " + WaitingStates[0], "statemanager");
SetState(WaitingStates[0]);
WaitingStates.RemoveAt(0);
}
}
public void Unload(States.State scene)
{
RKLog.Log("unload " + scene, "sceneloader");
Destroy(scenes[scene].gameobject);
scenes[scene].load = false;
scenes[scene].loaded = false;
scenes[scene].loading = false;
scenes[scene].gameobject = null;
//scenes.Remove(scene);
}
public void Load()
{
foreach (KeyValuePair <States.State, SceneData> entry in scenes)
{
SceneData scene = entry.Value;
if (scene.load == true && scene.loaded == false && scene.loading == false)
{
RKLog.Log("Load " + scene.name);
LoadScene(entry.Key);
}
}
}
private void ParseReturn <T>(HTTPRequest originalRequest, HTTPResponse response, SendTypes type, Action <ReturnTypes, T, int> action)
{
if (response == null)
{
RKLog.LogError("Parsereturn, response null ", "apicontroller");
action(ReturnTypes.ERROR, (T)(object)null, 1);
return;
}
GenericData returnResponse = new GenericData();
SendValueResponse res;
int returnerror;
//Debug.Log("parsereturn 2!");
// Debug.LogError("dit is iets ervoor");
// Debug.LogError(response.DataAsText);
ReturnTypes returntype;
switch (type)
{
default:
RKLog.Log("response: " + response.DataAsText);
res = JsonUtility.FromJson <SendValueResponse>(response.DataAsText);
foreach (ResponseStringList val in res.strings)
{
Debug.Log("set3: " + val.key + " to " + val.value);
returnResponse.Set(val.key, val.value);
}
foreach (ResponseIntList val in res.ints)
{
returnResponse.Set(val.key, val.value);
}
returntype = ReturnTypes.ERROR;
returnerror = -1;
if (res.success)
{
returntype = ReturnTypes.SUCCESS;
}
RKLog.Log("returntype: " + returntype + " returnresponse: " + returnResponse + " res error: " + res.error);
action(returntype, (T)(object)returnResponse, res.error);
break;
}
}
private bool SceneExists(States.State name)
{
if (scenes.ContainsKey(name))
{
return(true);
}
else
{
RKLog.Log("Scene " + name + " does not exist", "sceneloader");
return(false);
}
}
public SceneData Scene(States.State name)
{
if (SceneExists(name))
{
return(scenes[name]);
}
else
{
RKLog.Log("get scene " + name + " does not exist!", "sceneloader");
return(null);
}
}
public void Send(int userid, string type, GenericData data)
{
GenericData send = new GenericData();
send.Set("to", userid);
send.Set("type", type);
send.Set("msg", JsonConvert.SerializeObject(data.GetValues()));
string finaldata = JsonConvert.SerializeObject(send.GetValues());
RKLog.Log("send request to socket " + finaldata, "socketcontroller");
_websocket.Send(finaldata);
}
private void Disconnect()
{
RKLog.Log("disconnect socket server", "socketcontroller");
if (_websocket != null)
{
_websocket.OnOpen -= OnWebSocketOpen;
_websocket.OnMessage -= OnMessageReceived;
_websocket.OnClosed -= OnWebSocketClosed;
_websocket.OnError -= OnError;
_websocket.Close();
_websocket = null;
}
}
public void animateIn(SceneData sceneOut, SceneData sceneIn, SceneAnimator.Animations animation = SceneAnimator.Animations.LEFT, float speed = 0.5f, Ease ease = Ease.InOutQuad)
{
if (sceneIn != null && sceneOut != null)
{
RKLog.Log("SceneAnimator Animatein: " + sceneIn.name + " out: " + sceneOut.name + " speed " + speed + " dir ", "sceneanimator");
}
SceneAnimatorObject so = new SceneAnimatorObject(sceneIn, sceneOut, animation, speed, ease);
animations.Add(so);
if (!_animating)
{
animate();
}
}
private void Connect()
{
RKLog.Log("connect socket server", "socketcontroller");
Disconnect();
_websocket = new WebSocket(new Uri(Config.GetSocket()));
_websocket.OnOpen += OnWebSocketOpen;
_websocket.OnMessage += OnMessageReceived;
_websocket.OnClosed += OnWebSocketClosed;
_websocket.OnError += OnError;
_websocket.StartPingThread = true;
_websocket.PingFrequency = 2000;
_websocket.CloseAfterNoMesssage = TimeSpan.FromSeconds(4);
_websocket.Open();
}
private void stateChanged(States.State s)
{
RKLog.Log("Scenecontroller, statechanged " + s);
if (!SceneLoader.Instance.IsSceneLoaded(s))
{
RKLog.Log("Not loaded, load " + s);
_waitingStates.Add(s);
SceneLoader.Instance.LoadScene(s);
return;
}
else
{
animate(s, SceneAnimator.Animations.LEFT);
}
}
public void LoadScene(States.State name)
{
RKLog.Log("load scene " + name, "sceneloader");
if (scenes[name].loading == false && scenes[name].loaded == false)
{
// Debug.LogError(scenes[name].name);
scenes[name].loading = true;
GameObject g = HelperFunctions.GetPrefab2d(scenes[name].name, scenes[name].target);
if (g == null)
{
Debug.LogError("NO GAMEOBJECT LOADED " + name);
return;
}
SceneBaseClass sb = g.GetComponent <SceneBaseClass>();
if (sb == null)
{
Debug.LogError("NO SCENEBASECLASS LOADED " + name);
return;
}
scenes[name].gameobject = g;
scenes[name].Scene = sb;
scenes[name].loaded = true;
scenes[name].load = false;
scenes[name].loading = false;
bool issceneloaded = false;
sceneloaded.Invoke(name);
CheckLoadedAll();
}
else if (scenes[name].loaded)
{
Debug.LogError("Scene " + name + " already loaded");
}
}
public void SetState(States.State _state)
{
RKLog.Log("request " + _state + " currentstate " + _currentState, "statemanager");
if (locked)
{
RKLog.Log("setstate locked! " + _currentState, "statemanager");
WaitingStates.Add(_state);
return;
}
if (_state != _currentState)
{
if (_currentState != null)
{
if (_ignorenext == false)
{
_history.Add(_currentState);
}
else
{
_ignorenext = false;
}
}
_currentState = _state;
RKLog.Log("setstate " + _currentState, "statemanager");
Lock();
stateChanged.Invoke(_currentState);
//if (ignore == true) {
// _ignorenext = true;
//}
}
else if (_state == _currentState)
{
if (_currentState != null)
{
stateAgain.Invoke(_currentState);
}
}
}
public static void Log(string message, string tags = "", string color_string = "#00d632")
{
//Init();
if (!Enabled)
{
return;
}
if (RKLog.CompareTags(tags) == true && RKLog.CompareIgnoreTags(tags) == false || RKLog.AlwaysAllowedTypes.Contains(types.LOG))
{
if (message != _lastlog || IgnoreDoubles == false)
{
Debug.Log(
$"<color={color_string}>RK ({tags}): {message}</color>");
if (IgnoreDoubles == true)
{
_lastlog = message;
}
}
}
}
private void CheckState()
{
if (_websocket != null)
{
Debug.Log("websocket");
Debug.Log(_websocket);
_lastState = _websocket.State;
if (_websocket.State == WebSocketStates.Open)
{
RKLog.Log("checkstate " + _websocket.State + " counter " + _lastStateCounter + "connected: " + _connected + " latency: " + _websocket.Latency, "socketcontroller");
}
else
{
RKLog.Log("checkstate " + _websocket.State + " counter " + _lastStateCounter + "connected: " + _connected, "socketcontroller");
}
}
if (_connected == false)
{
Connect();
}
}
private void OnMessageReceived(WebSocket webSocket, string message)
{
RKLog.Log("OnMessageReceived: " + message, "socketcontroller");
SocketResponse data = JsonUtility.FromJson <SocketResponse>(message);
GenericData gd = new GenericData();
foreach (ResponseStringList item in data.data)
{
gd.Set(item.key, item.value);
}
RKLog.Log("invoke: " + gd.ToString(), "socketcontroller");
MessageReceived.Invoke(data.type, gd);
if (data.type == "update")
{
RKLog.Log("onmessagereceived, update: " + gd.ToString() + " dus poll", "socketcontroller");
}
}
private void build(string dir, float current, float offset, float totalvalue)
{
//Debug.LogError("hallo! "+ _width + "x"+_height);
//RKLog.LogError("build" + dir, " current " + current);
bool broken = false;
int nextkey = this._maxkey + 1;
if (dir == "up")
{
nextkey = this._minkey - 1;
}
if (nextkey < 0 && _nrOfItems != -1 || ((nextkey > (_nrOfItems - 1)) && _nrOfItems != -1))
{
// RKLog.LogError("INFINITESCROLLER BREAK0 " + this.gameObject.name, "infinitescroller");
return;
}
//Debug.LogError("build "+dir);
int counter = 0;
while (CheckCanRenderNext(dir, current, offset, totalvalue, broken))
{
if ((nextkey < 0 && _nrOfItems != -1) || ((nextkey > (_nrOfItems - 1)) && _nrOfItems != -1))
{
RKLog.LogError("INFINITESCROLLER BREAK1 " + this.gameObject.name, "infinitescroller");
break;
}
// RKLog.LogError("ja, render next " + current + "dir: " + dir + " nrofitems: "+ this._nrOfItems+ " : "+ this.gameObject.name + " nextkey: "+ nextkey + " >= "+ ( _nrOfItems - 1 ), "infinitescroller");
if (_nrOfItems == 0)
{
RKLog.LogError("INFINITESCROLLER2 HEEFT GEEN DATA " + this.gameObject.name, "infinitescroller");
break;
}
GameObject ob = _objectPool.getObject();
if (!ob)
{
RKLog.LogError("INFINITESCROLLER BREAK2 " + this.gameObject.name, "infinitescroller");
broken = true;
break;
}
if (dir == "up")
{
//Debug.LogError("got ob ");
}
//IInfiniteScrollPrefab obinterface = ob.GetInterface<IInfiniteScrollPrefab>();
//obinterface.setData<IInfiniteScrollPrefab>(_data);
//obinterface.setKey(nextkey);
// obinterface.SetKey(nextkey);
ob.name = nextkey.ToString();
//RKLog.LogError("Get nextkey " + nextkey + " length "+_nrOfItems, "infinitescroller");
if (nextkey <= _nrOfItems || _nrOfItems == -1)
{
_callback(nextkey, ob);
}
float size = ob.GetComponent <RectTransform>().sizeDelta.y;
if (direction == directions.Horizontal)
{
size = ob.GetComponent <RectTransform>().sizeDelta.x;
float add = 0;
if (dir == "up")
{
add = size;
}
ob.absolutePosition(new Vector2(current - add, 0));
}
else
{
float add = 0;
if (dir == "up")
{
add = size;
}
// Debug.LogError("add pixels " + size + " dir = "+dir+ " nextkey = " + nextkey + "current: " + current +" add: "+ add + " height: "+_height);
ob.absolutePosition(new Vector2(0, current + add));
//Debug.LogError("place on " + ob.x() + " - " + ob.y());
//Debug.LogError("place on "+(current + add));
}
//Debug.Log("check outeritem "+nextkey + " = "+ outerItem(nextkey));
if (outerItem(nextkey))
{
if (nextkey == 0)
{
if (direction == directions.Horizontal)
{
_scroller.maxX = 0;
if (_nrOfItems == 1)
{
_scroller.minX = 0;
}
}
else
{
_scroller.minY = 0 - ob.y() + _startpos;
if (_nrOfItems == 1)
{
if (buildDirection == builddirections.Backwards)
{
_scroller.maxY = (0 - ob.y() - _height) + size + _spacing;
_scroller.minY = _scroller.maxY;
}
else
{
_scroller.maxY = _scroller.minY;
}
}
}
}
else
{
if (direction == directions.Horizontal)
{
//Debug.LogError(ob.x());
_scroller.minX = (0 - ob.x() + _width) - size - _spacing;
}
else
{
//_scroller.maxY = (0-ob.y()-_height)+size+_spacing;
//float newheight = _height;
float scrollDistance = ((0 - ob.y()) + size + _spacing);
float dis = scrollDistance - _height;
RKLog.Log("maxy = " + scrollDistance + " height " + _height + " dis " + dis);
if (dis < 0)
{
dis = 0;
}
_scroller.maxY = dis;
RKLog.LogError("setting maxy, item " + nextkey + " maxy:" + _scroller.maxY + " oby: " + ob.y() + ", obj height " + size + " height: " + _height + " size: " + size + " spacing: " + _spacing + "");
//RKLog.LogError("maxy "+_scroller.GetComponent<RectTransform>().rect.height + " size: "+size + " spacing: "+ _spacing);
}
}
if (_scroller.minX > _scroller.maxX)
{
_scroller.minX = _scroller.maxX;
}
}
if (_scroller.minY > _scroller.maxY)
{
if (buildDirection == builddirections.Backwards)
{
_scroller.minY = _scroller.maxY;
}
else
{
_scroller.maxY = _scroller.minY;
}
}
// Debug.LogError("SET SCROLLER "+ _scroller.minY +"x" +_scroller.maxY);
counter++;
if ((direction == directions.Horizontal && dir == "down") || direction == directions.Vertical && dir == "up")
{
current = current + size + _spacing;
}
if ((direction == directions.Horizontal && dir == "up") || direction == directions.Vertical && dir == "down")
{
current = current - size - _spacing;
}
if (dir == "down")
{
// RKLog.LogError("nextkey down" + nextkey, "infinitescroller");
nextkey++;
}
else if (dir == "up")
{
// RKLog.LogError("nextkey up" +nextkey, "infinitescroller");
nextkey--;
}
///}
}
var currentpos = 0;
}
public void Unlock()
{
RKLog.Log("unlock " + _currentState, "statemanager");
locked = false;
CheckStates();
}
public void Lock()
{
RKLog.Log("lock " + _currentState, "statemanager");
locked = true;
}
public void SetSilentState(States.State _state)
{
RKLog.Log("SetSilentState " + _currentState, "statemanager");
_currentState = _state;
}
private void StateChanged(States.State state)
{
RKLog.Log("state changed to " + state.ToString());
}
public void SetKey(int key)
{
RKLog.LogError("Set Key " + key, "infinitescroller");
Rebuild(key);
}