public void AddObserver(IStateObserver observer)
{
if (!observers.Contains(observer))
{
observers.Add(observer);
}
}
public void RemoveObserver(IStateObserver _observer)
{
if (m_observerList.Contains(_observer))
{
m_observerList.Remove(_observer);
}
}
public void RemoveObserver(IStateObserver observer)
{
if (observers.Contains(observer))
{
observers.Remove(observer);
}
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
/// <param name="minPosition">minimální pozice motoru</param>
/// <param name="maxPosition">maximální pozice motoru</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration, int minPosition, int maxPosition, int minAngle, int maxAngle)
{
hasPositionLimit = true;
this.maxPosition = maxPosition;
this.minPosition = minPosition;
this.minAngle = minAngle;
this.maxAngle = maxAngle;
inicialize(connector, stateObserver, motorErrorOccuredObserver, nodeNumber, id, mode, reverse, multiplier, positionVelocity, positionAceleration, positionDeceleration, velocity, aceleration, deceleration);
}
public void AddObserver(IStateObserver _observer, bool _notifyCurrentState = false)
{
if (!m_observerList.Contains(_observer))
{
m_observerList.Add(_observer);
if (_notifyCurrentState)
{
_observer.UpdateState(MapState);
}
}
}
/// <summary>
/// Stop the timer.
/// </summary>
private void StopTimer(IStateObserver observer)
{
Timer timer = observerTimerList[observer];
if (null != timer)
{
timer.Stop();
}
observerTimerList.Remove(observer);
isFailed = false;
}
public TelloStateViewModel(
IUIDispatcher dispatcher,
IUINotifier notifier,
IStateObserver stateObserver,
IRepository repository,
ISession session)
: base(dispatcher, notifier)
{
this.stateObserver = stateObserver ?? throw new ArgumentNullException(nameof(stateObserver));
this.repository = repository ?? throw new ArgumentNullException(nameof(repository));
this.session = session ?? throw new ArgumentNullException(nameof(session));
}
/// <summary>
/// Stop the timer.
/// </summary>
private void StopTimer(IStateObserver observer)
{
Timer timer = observerTimerList[observer];
if (null != timer)
{
timer.Stop();
}
observerTimerList.Remove(observer);
isFailed = false;
}
private Timer ResolveTimer(IStateObserver observer)
{
if (observerTimerList.ContainsKey(observer))
{
return(observerTimerList[observer]);
}
else
{
Timer timer = CreateTimer();
observerTimerList.Add(observer, timer);
return(timer);
}
}
/// <summary>
/// ElapsedEventHandler for Timer
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">Elapsed Event Arguments</param>
private void OnTimedEvent(object sender, ElapsedEventArgs e)
{
Timer timer = (Timer)sender;
// Stop the timer and notify the observers.
timer.Stop();
isFailed = true;
// Notify only the hooked up observer.
IStateObserver observer = observerTimerList.First(list => list.Value.Equals(timer)).Key;
NotifyObserver(observer);
}
private Timer ResolveTimer(IStateObserver observer)
{
if (observerTimerList.ContainsKey(observer))
{
return observerTimerList[observer];
}
else
{
Timer timer = CreateTimer();
observerTimerList.Add(observer, timer);
return timer;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Observation" /> class.
/// </summary>
/// <param name="observer">The observer.</param>
/// <param name="observedComponent">The observed state</param>
/// <param name="updateObserverVersion">True if we should update the observer's observed version
/// at the end of the observation (default). False otherwise.</param>
internal Observation(IStateObserver observer, IStateComponent observedComponent, bool updateObserverVersion = true)
{
Assert.IsTrue(observer.ObservedStateComponents.Contains(observedComponent.StateSlotName),
$"Observer {observer.GetType().FullName} does not specify that it observes {observedComponent.StateSlotName}. Please add the state component to its {nameof(IStateObserver.ObservedStateComponents)}.");
m_ObservedComponent = observedComponent;
m_Observer = observer;
m_UpdateObserverVersion = updateObserverVersion;
var internalObserver = m_Observer as IInternalStateObserver;
var lastObservedVersion = internalObserver?.GetLastObservedComponentVersion(observedComponent.StateSlotName) ?? default;
UpdateType = m_ObservedComponent.GetUpdateType(lastObservedVersion);
LastObservedVersion = lastObservedVersion.Version;
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration)
{
try
{
this.mode = mode;
this.stateObserver = stateObserver;
this.motorErrorOccuredObserver = motorErrorOccuredObserver;
this.id = id;
this.multiplier = multiplier;
if (reverse)
{
rev = -1;
}
motor = connector.CreateDevice(Convert.ToUInt16(nodeNumber));
stateHandler = motor.Operation.MotionInfo;
sm = motor.Operation.StateMachine;
if (sm.GetFaultState())
{
sm.ClearFault();
}
sm.SetEnableState();
maxSpeed = (int)velocity;
velocityHandler = motor.Operation.ProfileVelocityMode;
velocityHandler.SetVelocityProfile(aceleration, deceleration);
positionHandler = motor.Operation.ProfilePositionMode;
positionHandler.SetPositionProfile(positionVelocity, positionAceleration, positionDeceleration);
homingHandler = motor.Operation.HomingMode;
changeMode(mode);
setStateObserver();
state = MotorState.enabled;
stateObserver.motorStateChanged(MotorState.enabled, "", id, 0, 0, 0, 0);
targetPosition = stateHandler.GetPositionIs();
targetAngle = getAngleFromPosition(targetPosition);
}
catch (DeviceException e)
{
sm = null;
disableStateObserver();
state = MotorState.error;
stateObserver.motorStateChanged(MotorState.error, String.Format("{0}\nError: {1}", e.ErrorMessage, errorDictionary.getComunicationErrorMessage(e.ErrorCode)), id, 0, 0, 0, 0);
}
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration)
{
this.mode = mode;
this.stateObserver = stateObserver;
this.motorErrorOccuredObserver = motorErrorOccuredObserver;
this.id = id;
this.multiplier = multiplier;
if (reverse)
{
rev = -1;
}
changeMode(mode);
setStateObserver();
state = MotorState.enabled;
stateObserver.motorStateChanged(MotorState.enabled, "", id, 0, 0, 0, 0);
}
public void Registerobserver(IStateObserver _observer)
{
if (_observer == null)
{
return;
}
lock (syncRoot)
{
//foreach (var component in _observer.observedstatecomponents)
//{
// if (!stateObservers.TryGetValue(component, out var observerforcomponent))
// stateObservers[component] = observerforcomponent = new List<IStateObserver>();
// if (!observerforcomponent.Contains(_observer))
// observerforcomponent.Add(_observer);
//}
}
}
/// <summary>
/// Inicializace připojení k motorům
/// </summary>
/// <param name="motorStateObserver">posluchač stavu motoru</param>
/// <param name="withChooseOfBus">příznak, zda při inicilizaci nechat uživatele nastavit parametry připojení</param>
/// <param name="motorErrorOccuredObserver">posluchač jakéhokoli eroru motoru</param>
/// <returns>chybovou hlášku nebo prázdný řetězec pokud nenastala chyba</returns>
public string inicialize(IStateObserver motorStateObserver, bool withChooseOfBus, Action motorErrorOccuredObserver)
{
error = false;
try
{
if (withChooseOfBus)
{
connector = new DeviceManager();
}
else
{
connector = new DeviceManager("EPOS2", "CANopen", "IXXAT_USB-to-CAN compact 0", "CAN0");
}
inicializeMotors(motorStateObserver, motorErrorOccuredObserver);
}
catch (DeviceException e)
{
//inicializeSimulation(motorStateObserver, motorErrorOccuredObserver); //odkomentovat pro softwarovou simulaci (a zakomentovat následující dva řádky)
error = true;
return String.Format("{0}\nError: {1}", e.ErrorMessage, errorDictionary.getComunicationErrorMessage(e.ErrorCode));
}
foreach (KeyValuePair<MotorId, IMotor> motor in motors)
{
motor.Value.enableStateObserver();
}
this.motorErrorOccuredObserver = motorErrorOccuredObserver;
foreach (KeyValuePair<MotorId, IMotor> motor in motors)
{
if (motor.Value.state == MotorState.error)
{
Thread thread = new Thread(motorErrorOccuredObserverFunction);
thread.Start();
break;
}
}
return "";
}
void Update(IStateObserver observer, GraphToolState state)
{
using (var observation = observer.ObserveState(state.ModelInspectorState))
{
var rebuildType = observation.UpdateType;
if (rebuildType == UpdateType.Complete)
{
m_SidePanelInspectorContainer.Clear();
if (state.ModelInspectorState.EditedNode != null)
{
m_SidePanelTitle.text = (state.ModelInspectorState.EditedNode as IHasTitle)?.Title ?? "Node Inspector";
m_Inspector = GraphElementFactory.CreateUI <ModelUI>(this, CommandDispatcher, state.ModelInspectorState.EditedNode);
if (m_Inspector != null)
{
m_SidePanelInspectorContainer.Add(m_Inspector);
}
}
else
{
m_Inspector = null;
m_SidePanelTitle.text = "Node Inspector";
}
}
}
using (var gvObservation = observer.ObserveState(state.GraphViewState))
{
var rebuildType = gvObservation.UpdateType;
if (rebuildType != UpdateType.None)
{
m_SidePanelTitle.text = (state.ModelInspectorState.EditedNode as IHasTitle)?.Title ?? "Node Inspector";
m_Inspector?.UpdateFromModel();
}
}
}
public void NextLevel(IStateObserver a_observer)
{
m_level++;
a_observer.LevelComplete();
}
public void AddObserver(IStateObserver observer)
{
stateObservers.Add(observer);
}
/// <summary>
/// Method to notify observer about the state change.
/// </summary>
private static void NotifyObserver(IStateObserver observer)
{
// Notify the observer who is hooked up with the timer.
observer.Notify();
}
//Observer Pattern
public void AddObserver(IStateObserver obs)
{
stateObservers.Add(obs);
Debug.Log("Add Observer " + obs + " successed.");
}
/// <summary>
/// Start the timer.
/// </summary>
private void StartTimer(IStateObserver observer)
{
ResolveTimer(observer).Start();
}
/// <summary>
/// Initiate the diagnosis
/// </summary>
/// <param name="observer">Object of type IStateObserver</param>
public void StartDiagnosis(IStateObserver observer)
{
// Starting a timer for this observer to keep track of changes
StartTimer(observer);
}
internal void Update(float a_elapsedTime, IStateObserver a_observer, ISpundObserver a_points)
{
UpdateEnemy(a_elapsedTime);
UpdatePlayer(a_elapsedTime, a_observer, a_points);
// a_model.Update(a_elapsedTime, a_points, a_model);
}
public void AddObserver(IStateObserver stateObserver, string observedStatePath)
{
var observersForStatePath = _observers.GetOrAdd(observedStatePath, new ConcurrentBag <IStateObserver>());
observersForStatePath.Add(stateObserver);
}
/// <summary>
/// Inicializace motorů
/// </summary>
/// <param name="motorStateObserver">posluchač stavu motoru</param>
/// <param name="motorErrorOccuredObserver">posluchač jakéhokoli eroru motoru</param>
private void inicializeMotors(IStateObserver motorStateObserver, Action motorErrorOccuredObserver)
{
motors[MotorId.PP_P].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 4, MotorId.PP_P, MotorMode.velocity, true, 1, (uint)Properties.Settings.Default["P_positionVelocity"], (uint)Properties.Settings.Default["P_positionAceleration"], (uint)Properties.Settings.Default["P_positionDeceleration"], (uint)Properties.Settings.Default["P_maxVelocity"], (uint)Properties.Settings.Default["P_aceleration"], (uint)Properties.Settings.Default["P_deceleration"]);
motors[MotorId.LP_P].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 8, MotorId.LP_P, MotorMode.velocity, false, 1, (uint)Properties.Settings.Default["P_positionVelocity"], (uint)Properties.Settings.Default["P_positionAceleration"], (uint)Properties.Settings.Default["P_positionDeceleration"], (uint)Properties.Settings.Default["P_maxVelocity"], (uint)Properties.Settings.Default["P_aceleration"], (uint)Properties.Settings.Default["P_deceleration"]);
motors[MotorId.LZ_P].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 12, MotorId.LZ_P, MotorMode.velocity, false, 1, (uint)Properties.Settings.Default["P_positionVelocity"], (uint)Properties.Settings.Default["P_positionAceleration"], (uint)Properties.Settings.Default["P_positionDeceleration"], (uint)Properties.Settings.Default["P_maxVelocity"], (uint)Properties.Settings.Default["P_aceleration"], (uint)Properties.Settings.Default["P_deceleration"]);
motors[MotorId.PZ_P].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 16, MotorId.PZ_P, MotorMode.velocity, true, 1, (uint)Properties.Settings.Default["P_positionVelocity"], (uint)Properties.Settings.Default["P_positionAceleration"], (uint)Properties.Settings.Default["P_positionDeceleration"], (uint)Properties.Settings.Default["P_maxVelocity"], (uint)Properties.Settings.Default["P_aceleration"], (uint)Properties.Settings.Default["P_deceleration"]);
motors[MotorId.PP_R].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 3, MotorId.PP_R, MotorMode.position, false, 4, (uint)Properties.Settings.Default["R_positionVelocity"], (uint)Properties.Settings.Default["R_positionAceleration"], (uint)Properties.Settings.Default["R_positionDeceleration"], 1, 1, 1, -216502, 433004, -90, 180);
motors[MotorId.LP_R].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 7, MotorId.LP_R, MotorMode.position, false, 4, (uint)Properties.Settings.Default["R_positionVelocity"], (uint)Properties.Settings.Default["R_positionAceleration"], (uint)Properties.Settings.Default["R_positionDeceleration"], 1, 1, 1, -216502, 433004, -90, 180);
motors[MotorId.LZ_R].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 11, MotorId.LZ_R, MotorMode.position, false, 4, (uint)Properties.Settings.Default["R_positionVelocity"], (uint)Properties.Settings.Default["R_positionAceleration"], (uint)Properties.Settings.Default["R_positionDeceleration"], 1, 1, 1, -216502, 433004, -90, 180);
motors[MotorId.PZ_R].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 15, MotorId.PZ_R, MotorMode.position, false, 4, (uint)Properties.Settings.Default["R_positionVelocity"], (uint)Properties.Settings.Default["R_positionAceleration"], (uint)Properties.Settings.Default["R_positionDeceleration"], 1, 1, 1, -216502, 433004, -90, 180);
motors[MotorId.PP_Z].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 2, MotorId.PP_Z, MotorMode.position, false, 4, (uint)Properties.Settings.Default["Z_positionVelocity"], (uint)Properties.Settings.Default["Z_positionAceleration"], (uint)Properties.Settings.Default["Z_positionDeceleration"], 1, 1, 1, motorZAngleMap);
motors[MotorId.LP_Z].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 6, MotorId.LP_Z, MotorMode.position, false, 4, (uint)Properties.Settings.Default["Z_positionVelocity"], (uint)Properties.Settings.Default["Z_positionAceleration"], (uint)Properties.Settings.Default["Z_positionDeceleration"], 1, 1, 1, motorZAngleMap);
motors[MotorId.LZ_Z].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 10, MotorId.LZ_Z, MotorMode.position, false, 4, (uint)Properties.Settings.Default["Z_positionVelocity"], (uint)Properties.Settings.Default["Z_positionAceleration"], (uint)Properties.Settings.Default["Z_positionDeceleration"], 1, 1, 1, motorZAngleMap);
motors[MotorId.PZ_Z].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 14, MotorId.PZ_Z, MotorMode.position, false, 4, (uint)Properties.Settings.Default["Z_positionVelocity"], (uint)Properties.Settings.Default["Z_positionAceleration"], (uint)Properties.Settings.Default["Z_positionDeceleration"], 1, 1, 1, motorZAngleMap);
motors[MotorId.PP_ZK].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 1, MotorId.PP_ZK, MotorMode.position, false, 4, (uint)Properties.Settings.Default["ZK_positionVelocity"], (uint)Properties.Settings.Default["ZK_positionAceleration"], (uint)Properties.Settings.Default["ZK_positionDeceleration"], 1, 1, 1, -110000, 108000, -45, 45);
motors[MotorId.LP_ZK].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 5, MotorId.LP_ZK, MotorMode.position, false, 4, (uint)Properties.Settings.Default["ZK_positionVelocity"], (uint)Properties.Settings.Default["ZK_positionAceleration"], (uint)Properties.Settings.Default["ZK_positionDeceleration"], 1, 1, 1, -110000, 108000, -45, 45);
motors[MotorId.LZ_ZK].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 9, MotorId.LZ_ZK, MotorMode.position, false, 4, (uint)Properties.Settings.Default["ZK_positionVelocity"], (uint)Properties.Settings.Default["ZK_positionAceleration"], (uint)Properties.Settings.Default["ZK_positionDeceleration"], 1, 1, 1, -110000, 108000, -45, 45);
motors[MotorId.PZ_ZK].inicialize(connector, motorStateObserver, motorErrorOccuredObserver, 13, MotorId.PZ_ZK, MotorMode.position, false, 4, (uint)Properties.Settings.Default["ZK_positionVelocity"], (uint)Properties.Settings.Default["ZK_positionAceleration"], (uint)Properties.Settings.Default["ZK_positionDeceleration"], 1, 1, 1, -110000, 108000, -45, 45);
}
/// <summary>
/// Stop Diagnosis
/// </summary>
/// <param name="observer">Object of type IStateObserver</param>
public void StopDiagnosis(IStateObserver observer)
{
// Stop the timer as the caller is stopping the diagnosis.
StopTimer(observer);
}
/// <summary>
/// Inicializuje softwarovou simulaci robota
/// </summary>
/// <param name="motorStateObserver">posluchač stavu motoru</param>
/// <param name="motorErrorOccuredObserver">posluchač jakéhokoli eroru motoru</param>
private void inicializeSimulation(IStateObserver motorStateObserver, Action motorErrorOccuredObserver)
{
test = true;
motors.Clear();
var motorsIds = MotorId.GetValues(typeof(MotorId));
foreach (MotorId motorId in motorsIds)
{
motors.Add(motorId, new TestMotor());
}
inicializeMotors(motorStateObserver, motorErrorOccuredObserver);
}
/// <summary>
/// Creates a new <see cref="Observation"/> instance that will not update the observer's last observed version.
/// </summary>
/// <param name="observer">The observer.</param>
/// <param name="stateComponent">The observed state component.</param>
/// <returns>An <see cref="Observation"/> object.</returns>
public static Observation PeekAtState(this IStateObserver observer, IStateComponent stateComponent)
{
return(new Observation(observer, stateComponent, false));
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
/// <param name="minPosition">minimální pozice motoru</param>
/// <param name="maxPosition">maximální pozice motoru</param>
/// <param name="angleMap">Pole definující vztah úhlu ze škály uvedené u motoru a opravdového úhlu a pozicí motoru. Jeden řádek obsahuje {úhel ze škály ve stupních; opravdový úhel; pozice motoru}</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration, int[,] angleMap)
{
this.angleMap = angleMap;
inicialize(connector, stateObserver, motorErrorOccuredObserver, nodeNumber, id, mode, reverse, multiplier, positionVelocity, positionAceleration, positionDeceleration, velocity, aceleration, deceleration, angleMap[angleMap.GetLength(0) - 1, 2], angleMap[0, 2], angleMap[angleMap.GetLength(0) - 1, 1], angleMap[0, 1]);
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------\\
//Collision for Player
private Vector2 Collide(Vector2 a_oldPos, Vector2 a_newPos, Vector2 a_size, ref Vector2 a_velocity, out bool a_outCollideGround, IStateObserver a_observer)
{
a_outCollideGround = false;
//if(m_level.Fall(a_newPos))
// {
// return new Vector2(6.0f, 16f);
// }
//if (m_level.IsCollidingAtTrap(a_newPos, a_size))
//{
// m_level.Restart(a_observer);
// return new Vector2(6.0f, 16f);
// }
// if (m_level.IsCollidingAtEnemy(a_newPos, a_size))
// {
// DoStartOver();
// return new Vector2(6.0f, 16f);
// }
// if (CollideWithEnemyTwo(a_newPos)==true)
// {
// return new Vector2(6.0f, 16f);
// }
if (m_level.IsCollidingAt(a_newPos, a_size))
{
//if not try only the X movement, indicates that a collision with ground or roof has occured
Vector2 xMove = new Vector2(a_newPos.X, a_oldPos.Y);
if (a_velocity.Y > 0 && a_oldPos.Y - (int)a_oldPos.Y > 0.9f)
{
xMove.Y = (int)a_oldPos.Y + 0.99f;
}
if (m_level.IsCollidingAt(xMove, a_size) == false)
{
//did we collide with ground?
if (a_velocity.Y > 0)
{
a_outCollideGround = true;
a_velocity.Y = 0; //no bounce
}
else
{
//collide with roof
a_velocity.Y *= 0.0f; //reverse the y velocity and some speed lost in the collision
}
a_velocity.X *= 0.10f;// friction should be time-dependant
return xMove;
}
else
{
//try Y movement, indicates that a collision with wall has occured
Vector2 yMove = new Vector2(a_oldPos.X, a_newPos.Y);
if (m_level.IsCollidingAt(yMove, a_size) == false)
{
a_velocity.X *= 0.5f;
return yMove;
}
if (a_velocity.Y > 0)
{
a_outCollideGround = true;
}
a_velocity.X = 0; //no bounce
a_velocity.Y = 0; //no bounce
}
//remain at the same position
return a_oldPos;
}
if (m_level.IsCollidingAtBrick(a_newPos, a_size))
{
Vector2 xMove = new Vector2(a_newPos.X, a_oldPos.Y);
if (a_velocity.Y > 0 && a_oldPos.Y - (int)a_oldPos.Y > 0.9f)
{
xMove.Y = (int)a_oldPos.Y + 0.99f;
}
if (m_level.IsCollidingAtBrick(xMove, a_size) == false)
{
//did we collide with ground?
if (a_velocity.Y > 0)
{
a_outCollideGround = true;
a_velocity.Y = 0; //no bounce
}
else
{
//collide with roof
a_velocity.Y *= 0.0f; //reverse the y velocity and some speed lost in the collision
}
a_velocity.X *= 0.10f;// friction should be time-dependant
return xMove;
}
else
{
//try Y movement, indicates that a collision with wall has occured
Vector2 yMove = new Vector2(a_oldPos.X, a_newPos.Y);
if (m_level.IsCollidingAtBrick(yMove, a_size) == false)
{
a_velocity.X *= 0.0f;
return yMove;
}
if (a_velocity.Y > 0)
{
a_outCollideGround = true;
}
a_velocity.X = 0; //no bounce
a_velocity.Y = 0; //no bounce
}
//remain at the same position
return a_oldPos;
}
if (m_level.IsCollidingAtBreak(a_newPos, a_size))
{
Vector2 xMove = new Vector2(a_newPos.X, a_oldPos.Y);
if (m_level.IsCollidingAt(xMove, a_size) == false)
{
//did we collide with ground?
if (a_velocity.Y > 0)
{
a_outCollideGround = true;
}
a_velocity.Y *= 0; //reverse the y velocity and some speed lost in the collision
a_velocity.X *= 0;// friction should be time-dependant
return xMove;
}
else
{
//try Y movement, indicates that a collision with wall has occured
Vector2 yMove = new Vector2(a_oldPos.X, a_newPos.Y);
if (m_level.IsCollidingAt(yMove, a_size) == false)
{
a_velocity.X = 0;
// a_velocity.Y = 0;
return yMove;
}
}
//remain at the same position
return a_oldPos;
}
return a_newPos;
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration)
{
try
{
this.mode = mode;
this.stateObserver = stateObserver;
this.motorErrorOccuredObserver = motorErrorOccuredObserver;
this.id = id;
this.multiplier = multiplier;
if (reverse)
{
rev = -1;
}
motor = connector.CreateDevice(Convert.ToUInt16(nodeNumber));
stateHandler = motor.Operation.MotionInfo;
sm = motor.Operation.StateMachine;
if (sm.GetFaultState())
sm.ClearFault();
sm.SetEnableState();
maxSpeed = (int)velocity;
velocityHandler = motor.Operation.ProfileVelocityMode;
velocityHandler.SetVelocityProfile(aceleration, deceleration);
positionHandler = motor.Operation.ProfilePositionMode;
positionHandler.SetPositionProfile(positionVelocity, positionAceleration, positionDeceleration);
homingHandler = motor.Operation.HomingMode;
changeMode(mode);
setStateObserver();
state = MotorState.enabled;
stateObserver.motorStateChanged(MotorState.enabled, "", id, 0, 0, 0, 0);
targetPosition = stateHandler.GetPositionIs();
targetAngle = getAngleFromPosition(targetPosition);
}
catch (DeviceException e)
{
sm = null;
disableStateObserver();
state = MotorState.error;
stateObserver.motorStateChanged(MotorState.error, String.Format("{0}\nError: {1}", e.ErrorMessage, errorDictionary.getComunicationErrorMessage(e.ErrorCode)), id, 0, 0, 0, 0);
}
}
internal void UpdatePlayer(float a_elapsedTime, IStateObserver a_observer, ISpundObserver a_points)
{
Vector2 oldPos = m_player.GetPosition();
//get a new position for the player
m_player.Update(a_elapsedTime);
Vector2 newPos = m_player.GetPosition();
m_hasCollidedWithGround = false;
Vector2 speed = m_player.GetSpeed();
Vector2 afterCollidedPos = Collide(oldPos, newPos, m_player.m_sizes, ref speed, out m_hasCollidedWithGround, a_observer);
//set the new speed and position after collision
m_player.SetPosition(afterCollidedPos.X, afterCollidedPos.Y);
m_player.SetPosition(afterCollidedPos.X, afterCollidedPos.Y);
m_player.SetSpeed(speed.X, speed.Y);
if (afterCollidedPos.X > Level.g_levelWidth - 3)
{
speed = new Vector2(0.0f, 0.0f);
afterCollidedPos = new Vector2(5.0f, 0.0f);
m_level.NextLevel(a_observer);
}
if(m_level.IsCollidingAtEscape(newPos, m_player.m_sizes))
{
m_level.GameCompleted(a_observer);
}
if (m_level.IsCollidingAtPoint(newPos, m_player.m_sizes, a_points))
{
m_player.GaindPoint();
// m_level.CountPoint(a_points);
}
if(m_level.Fall(newPos, a_points))
{
m_level.Restart(a_observer);
}
if (m_level.IsCollidingAtEnemy(newPos, m_player.m_sizes, a_points))
{
m_level.Restart(a_observer);
DoStartOver();
}
if (CollideWithEnemyTwo(newPos, a_points) == true)
{
m_level.Restart(a_observer);
new Vector2(5.0f, 16f);
}
if (m_level.IsCollidingAtTrap(newPos, m_player.m_sizes, a_points))
{
m_level.Restart(a_observer);
// return new Vector2(6.0f, 16f);
}
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
/// <param name="minPosition">minimální pozice motoru</param>
/// <param name="maxPosition">maximální pozice motoru</param>
/// <param name="angleMap">Pole definující vztah úhlu ze škály uvedené u motoru a opravdového úhlu a pozicí motoru. Jeden řádek obsahuje {úhel ze škály ve stupních; opravdový úhel; pozice motoru}</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration, int[,] angleMap)
{
this.angleMap = angleMap;
inicialize(connector, stateObserver, motorErrorOccuredObserver, nodeNumber, id, mode, reverse, multiplier, positionVelocity, positionAceleration, positionDeceleration, velocity, aceleration, deceleration, angleMap[angleMap.GetLength(0) - 1, 2], angleMap[0, 2], angleMap[angleMap.GetLength(0) - 1, 1], angleMap[0, 1]);
}
/// <summary>
/// Method to notify observer about the state change.
/// </summary>
private static void NotifyObserver(IStateObserver observer)
{
// Notify the observer who is hooked up with the timer.
observer.Notify();
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
/// <param name="minPosition">minimální pozice motoru</param>
/// <param name="maxPosition">maximální pozice motoru</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration, int minPosition, int maxPosition, int minAngle, int maxAngle)
{
hasPositionLimit = true;
this.maxPosition = maxPosition;
this.minPosition = minPosition;
this.minAngle = minAngle;
this.maxAngle = maxAngle;
inicialize(connector, stateObserver, motorErrorOccuredObserver, nodeNumber, id, mode, reverse, multiplier, positionVelocity, positionAceleration, positionDeceleration, velocity, aceleration, deceleration);
}
/// <summary>
/// Stop Diagnosis
/// </summary>
/// <param name="observer">Object of type IStateObserver</param>
public void StopDiagnosis(IStateObserver observer)
{
// Stop the timer as the caller is stopping the diagnosis.
StopTimer(observer);
}
/// <summary>
/// Creates a new <see cref="Observation"/> instance that will update the observer's last observed version.
/// </summary>
/// <param name="observer">The observer.</param>
/// <param name="stateComponent">The observed state component.</param>
/// <returns>An <see cref="Observation"/> object.</returns>
public static Observation ObserveState(this IStateObserver observer, IStateComponent stateComponent)
{
return(new Observation(observer, stateComponent));
}
public bool RemoveObserver(IStateObserver obs)
{
return(stateObservers.Remove(obs));
}
public void GameCompleted(IStateObserver a_observer)
{
m_level=1;
a_observer.GameComplete();
}
public ObservableMatchesManagerDecorator(IMatchesManager inner, IStateObserver <MatchStateCommand> observer, TeamRankingsDbContext context)
{
_inner = inner;
_observer = observer;
_context = context;
}
public void Restart(IStateObserver a_observer)
{
GenerateLevel();
a_observer.GameOver();
}
/// <summary>
/// Initiate the diagnosis
/// </summary>
/// <param name="observer">Object of type IStateObserver</param>
public void StartDiagnosis(IStateObserver observer)
{
// Starting a timer for this observer to keep track of changes
StartTimer(observer);
}
public void RemoveObserver(IStateObserver observer)
{
stateObservers.Remove(observer);
}
/// <summary>
/// Start the timer.
/// </summary>
private void StartTimer(IStateObserver observer)
{
ResolveTimer(observer).Start();
}
/// <summary>
/// Inicializace motoru
/// </summary>
/// <param name="connector">connector sběrnice</param>
/// <param name="stateObserver">posluchač stavu motoru</param>
/// <param name="nodeNumber">číslo node</param>
/// <param name="id">id motoru</param>
/// <param name="mode">defaultní nastavení módu</param>
/// <param name="reverse">příznak obrácení směru točení</param>
/// <param name="multiplier">násobitel otáček v případě, že je motor za převodovkou</param>
/// <param name="positionVeocity">rychlost motoru v otáčkách při pozicování</param>
/// <param name="positionAceleration">zrychlení motoru v otáčkách při pozicování</param>
/// <param name="positionDeceleration">zpomalení motoru v otáčkách při pozicování</param>
/// <param name="velocity">maximální rychlost motoru při rychlostním řízení</param>
/// <param name="aceleration">zrychlení motoru při rychlostním řízení</param>
/// <param name="deceleration">zpomalení motoru při rychlostním řízení</param>
public void inicialize(DeviceManager connector, IStateObserver stateObserver, Action motorErrorOccuredObserver, int nodeNumber, MotorId id, MotorMode mode, bool reverse, int multiplier, uint positionVelocity, uint positionAceleration, uint positionDeceleration, uint velocity, uint aceleration, uint deceleration)
{
this.mode = mode;
this.stateObserver = stateObserver;
this.motorErrorOccuredObserver = motorErrorOccuredObserver;
this.id = id;
this.multiplier = multiplier;
if (reverse)
{
rev = -1;
}
changeMode(mode);
setStateObserver();
state = MotorState.enabled;
stateObserver.motorStateChanged(MotorState.enabled, "", id, 0, 0, 0, 0);
}
