public bool CheckBottomObstacleCollision(MovableObject obj, Obstacle platform) { obj.CollisionBox = new Rectangle((int)obj.Position.X, (int)obj.Position.Y, obj.SelectedAnimation.FrameWidth, obj.SelectedAnimation.FrameHeight); Rectangle bottom = new Rectangle((int)platform.Position.X + 5, (int)platform.Position.Y + platform.Texture.Height, platform.Texture.Width - 10, 10); return CollisionBottom = (obj.CollisionBox.Intersects(bottom)); }
public bool CheckLeftObstacleCollision(MovableObject obj, Obstacle platform) { Rectangle collisionBox = obj.CollisionBox = new Rectangle((int)obj.Position.X, (int)obj.Position.Y, obj.Texture.Width, obj.Texture.Height); Rectangle left = new Rectangle((int)platform.Position.X - 10, (int)platform.Position.Y + 5, 10, platform.Texture.Height - 10); return CollisionLeft = (obj.CollisionBox.Intersects(left)); }
private ThrowObject createThrowObject(MovableObject objectType) { ThrowObject throwObject = new ThrowObject(); throwObject.SetThrower(objectType); throwObject.Initialize(); return throwObject; }
public void Use(MovableObject movableObject) { if (_doneSpawningMinions) { _minionOwner = movableObject; SpawnMinions(); _doneSpawningMinions = false; } }
public void Use(MovableObject movableObject) { movableObject.GetLevel().Player.Hit(300); _needToStopFlashing = false; _flashTimer.Elapsed += new ElapsedEventHandler(StopFlashing); _flashTimer.Interval = 1000; _flashTimer.Start(); _screenSize = movableObject.ScreenBound; }
/// <summary> /// Reacts on enemy moveble object, starts occupation or just move. /// </summary> /// <param name="point">The mouse position.</param> /// <param name="hitObject">The result of a HitTest.</param> /// <param name="isFriendly">The information if the hitted object is friendly.</param> /// <param name="isMovableGameObject">The information if the hitted object is movable.</param> /// <returns>Returns a required action.</returns> public override ActionAnswer OnMouseAction(Vector3 point, MovableObject hitTarget, bool isFriendly, bool isMovableGameObject) { if (hitTarget != null) { if (!isFriendly) { if (isMovableGameObject) { return ActionAnswer.Occupy; } } } return ActionAnswer.Move; }
public ThrowObject GetThrowObject(MovableObject thrower) { foreach (ThrowObject FoundThrownObject in _level.ThrownObjects) { if (FoundThrownObject.GetThrower() == thrower) { return FoundThrownObject; } } return null; }
// methods public bool Attack(MovableObject enemy) { //double enemyAtacs = this.Life / enemy.AttackPower; //double heroAttacs = enemy.Life / this.AttackPower; if (enemy.AttackPower <= this.AttackPower) { this.Experience += enemy.Life; this.AttackPower += this.Experience / 10; return true; } return false; }
public void Use(MovableObject objectType) { CollisionDetector collisionDetector = CollisionDetector.GetInstance(); isBeingUsed = true; _position = new Vector2(objectType.Position.X + 30, objectType.Position.Y + 5); _collisionBox = new Rectangle((int)_position.X, (int) _position.Y, _texture.Width, _texture.Height); for (int movableObjects_inc = 0; movableObjects_inc < _level.GetMovableObjects().Count(); movableObjects_inc++) { if (_level.GetMovableObjects()[movableObjects_inc] is Enemy) { Enemy enemy = (Enemy)_level.GetMovableObjects()[movableObjects_inc]; if(collisionDetector.CheckCollision(_collisionBox, enemy.CollisionBox)) { _level.GetMovableObjects().Remove(enemy); _level.Layers[1].Sprites.Remove(enemy); } } } }
public static CommandMovableObjectMove MOVE_OBJECT_DELAY(MovableObject obj, float delayTime, string keyframe, Vector3 startPos, Vector3 targetPos, float onceLength) { return(MOVE_OBJECT_DELAY_EX(obj, delayTime, keyframe, startPos, targetPos, onceLength, false, 0.0f, null, null)); }
public static void MOVE_OBJECT_EX(MovableObject obj, Vector3 start, Vector3 target, float onceLength, KeyFrameCallback moveDoneCallback) { MOVE_OBJECT_EX(obj, CommonDefine.ZERO_ONE, start, target, onceLength, false, 0.0f, null, moveDoneCallback); }
public static CommandMovableObjectRotateSpeedPhysics ROTATE_SPEED_OBJECT_PHY_DELAY(MovableObject obj, float delayTime, Vector3 speed, Vector3 startAngle) { return(ROTATE_SPEED_OBJECT_PHY_DELAY(obj, delayTime, speed, startAngle, Vector3.zero)); }
private static bool IsObjectIngameAndSelectable(MovableObject movableObject) { foreach (var item in unitList) { if (item.sceneNode == movableObject.ParentNode) return true; } return false; }
static void selectObject(MovableObject obj) { obj.ParentSceneNode.ShowBoundingBox = true; unitList.Add(FindOwningUnit(obj.ParentSceneNode)); }
void OnMapObjectChanged(MovableObject ob, IntPoint3 l, MapTileObjectChangeType changeType) { if (!m_box.Contains(l)) return; switch (changeType) { case MapTileObjectChangeType.Add: Debug.Assert(!m_objects.Contains(ob)); m_objects.Add(ob); break; case MapTileObjectChangeType.Remove: bool ok = m_objects.Remove(ob); Debug.Assert(ok); break; case MapTileObjectChangeType.Update: break; default: throw new Exception(); } }
public static void TRACK_TARGET(MovableObject obj, float speed, MovableObject target, TrackDoneCallback doneCallback) { TRACK_TARGET(obj, speed, target, Vector3.zero, doneCallback); }
public bool CheckTopObstacleCollision(MovableObject obj, Obstacle platform) { Rectangle collisionBox = obj.CollisionBox = new Rectangle((int)obj.Position.X, (int)obj.Position.Y, obj.Texture.Width, obj.Texture.Height); Rectangle top = new Rectangle((int)platform.Position.X + 5, (int)platform.Position.Y - 10, platform.Texture.Width - 10, 10); return CollisionTop = (obj.CollisionBox.Intersects(top)); }
void MapObjectChangedCallback(MovableObject ob, IntPoint3 l, MapTileObjectChangeType changetype) { if (!m_renderView.Contains(l)) return; InvalidateTileData(); }
public SimNode(SceneNode root, MovableObject movableObject) { SceneNode = root.CreateChildSceneNode(); SceneNode.AttachObject(movableObject); }
/********************************************************** * FUNÇÕES **********************************************************/ void OnEnable() { moveTarget = target as MovableObject; if(moveTarget.moviments == null) moveTarget.moviments = new List<IMove>(); movimentsSize = moveTarget.moviments.Count; movimentsType = new List<MoveType>(); MoveType currentMove; foreach(IMove move in moveTarget.moviments) { currentMove = new MoveType(); currentMove.move = move; if(move is TrackingMove) currentMove.moveType = MOVE_TYPE.TRACKING; else currentMove.moveType = MOVE_TYPE.FIPLABLE; } }
public void AddToIgnoreList(MovableObject obj) { foreach (var mode in _cameraModes) { if (mode.Value is ICollidableCamera) { (mode.Value as ICollidableCamera).AddToIgnoreList(obj); } } }
public void Use(MovableObject objectType) { ThrowObject throwObject = createThrowObject(objectType); _level.ThrownObjects.Add(throwObject); }
public static CommandMovableObjectMovePhysics MOVE_OBJECT_PHY_DELAY_EX(MovableObject obj, float delayTime, Vector3 start, Vector3 target, float onceLength, KeyFrameCallback movingCallback, KeyFrameCallback moveDoneCallback) { return(MOVE_OBJECT_PHY_DELAY_EX(obj, delayTime, CommonDefine.ZERO_ONE, start, target, onceLength, false, 0.0f, movingCallback, moveDoneCallback)); }
public bool ValidateAttack(MovableObject victim) { foreach(MovableObject m in _victims) { if(m == victim) return false; } _victims.Add(victim); return true; }
public static CommandMovableObjectActive ACTIVE_OBJECT_DELAY(MovableObject obj, bool active, float delayTime) { return(ACTIVE_OBJECT_DELAY_EX(obj, active, delayTime, null, null)); }
private void selectSceneNode(MovableObject moveableObject) { chat(moveableObject.Name); moveableObject.ParentSceneNode.ShowBoundingBox = true; selectedNodes.Add(moveableObject); }
void WheelsSkeletonAnimationMeshObject_AddToRenderQueue( MovableObject sender, Camera camera, bool onlyShadowCasters, ref bool allowRender ) { float renderTime = RendererWorld.Instance.FrameRenderTime; if( wheelsSkeletonAnimationRenderTime != renderTime ) { wheelsSkeletonAnimationRenderTime = renderTime; if( wheelsSkeletonAnimationNeedUpdate ) { UpdateWheelsSkeletonAnimation(); wheelsSkeletonAnimationNeedUpdate = false; } } }
public bool CheckObstacleCollision(MovableObject obj, Obstacle platform) { if (CheckBottomObstacleCollision(obj, platform) || CheckLeftObstacleCollision(obj, platform) || CheckRightObstacleCollision(obj, platform) || CheckTopObstacleCollision(obj, platform) == true) return true; else return false; }
void FollowedObjectMoved(MovableObject ob, ContainerObject dst, IntPoint3 loc) { EnvironmentObject env = dst as EnvironmentObject; if (env != null) { map.CenterPos = new Point(loc.X, loc.Y); map.Z = loc.Z; } }
public static void MOVE_OBJECT_PHY(MovableObject obj, Vector3 start, Vector3 target, float onceLength) { MOVE_OBJECT_PHY_EX(obj, CommonDefine.ZERO_ONE, start, target, onceLength, false, 0.0f, null, null); }
public static void ROTATE_SPEED_OBJECT_PHY(MovableObject obj, Vector3 speed, Vector3 startAngle) { ROTATE_SPEED_OBJECT(obj, speed, startAngle, Vector3.zero); }
public static void MOVE_OBJECT_PHY(MovableObject obj, string fileName, Vector3 startPos, Vector3 targetPos, float onceLength) { MOVE_OBJECT_PHY_EX(obj, fileName, startPos, targetPos, onceLength, false, 0.0f, null, null); }
public static CommandMovableObjectRotateSpeedPhysics ROTATE_SPEED_OBJECT_PHY_DELAY(MovableObject obj, float delayTime, Vector3 speed, Vector3 startAngle, Vector3 rotateAccelerationValue) { CommandMovableObjectRotateSpeedPhysics cmd = newCmd(out cmd, false, true); cmd.mRotateSpeed = speed; cmd.mStartAngle = startAngle; cmd.mRotateAcceleration = rotateAccelerationValue; pushDelayCommand(cmd, obj, delayTime); return(cmd); }
public static void MOVE_OBJECT_PHY(MovableObject obj, string fileName, Vector3 startPos, Vector3 targetPos, float onceLength, bool loop, float offset) { MOVE_OBJECT_PHY_EX(obj, fileName, startPos, targetPos, onceLength, loop, offset, null, null); }
public static void ROTATE_OBJECT(MovableObject obj, Vector3 start, Vector3 target, float time) { ROTATE_OBJECT_EX(obj, CommonDefine.ZERO_ONE, start, target, time, false, 0.0f, null, null); }
public static CommandMovableObjectMovePhysics MOVE_OBJECT_PHY_DELAY(MovableObject obj, float delayTime, Vector3 start, Vector3 target, float onceLength) { return(MOVE_OBJECT_PHY_DELAY_EX(obj, delayTime, CommonDefine.ZERO_ONE, start, target, onceLength, false, 0.0f, null, null)); }
public static void ROTATE_OBJECT_EX(MovableObject obj, Vector3 start, Vector3 target, float time, KeyFrameCallback doneCallback) { ROTATE_OBJECT_EX(obj, CommonDefine.ZERO_ONE, start, target, time, false, 0.0f, null, doneCallback); }
void TrackMeshObject_AddToRenderQueue( MovableObject sender, Camera camera, bool onlyShadowCasters, ref bool allowRender) { //tracks animation if( camera != RendererWorld.Instance.DefaultCamera ) return; if( leftTrack.meshObject == null ) return; //!!!!!need speed for each track float speed = GetTracksSpeed(); Track track = leftTrack.meshObject == sender ? leftTrack : rightTrack; Vec2 value = track.materialScrollValue + Type.TracksAnimationMultiplier * ( speed * RendererWorld.Instance.FrameRenderTimeStep ); while( value.X < 0 ) value.X++; while( value.X >= 1 ) value.X--; while( value.Y < 0 ) value.Y++; while( value.Y >= 1 ) value.Y--; track.materialScrollValue = value; Vec4 programValue; if( EntitySystemWorld.Instance.Simulation ) programValue = new Vec4( track.materialScrollValue.X, track.materialScrollValue.Y, 0, 0 ); else programValue = Vec4.Zero; foreach( MeshObject.SubObject subObject in track.meshObject.SubObjects ) { //update SubObject dynamic gpu parameter subObject.SetCustomGpuParameter( (int)ShaderBaseMaterial.GpuParameters.diffuse1MapTransformAdd, programValue ); } }
public static void MOVE_OBJECT_PHY_EX(MovableObject obj, Vector3 start, Vector3 target, float onceLength, float offsetTime, KeyFrameCallback movingCallback, KeyFrameCallback moveDoneCallback) { MOVE_OBJECT_PHY_EX(obj, CommonDefine.ZERO_ONE, start, target, onceLength, false, offsetTime, movingCallback, moveDoneCallback); }
/// <summary> /// do nothing /// </summary> /// <param name="who"></param> public override bool Push(MovableObject who, Position dir) { return(false); }
public static void ROTATE_OBJECT(MovableObject obj, string keyframe, Vector3 start, Vector3 target, float onceLength) { ROTATE_OBJECT_EX(obj, keyframe, start, target, onceLength, false, 0.0f, null, null); }
protected override void CreateScene() { mLog = LogManager.Singleton.createLog("RSQTest.log", false, true); mLog.LogMessage(string.Format("RSQTest log {0}", System.DateTime.Now)); create4LineDebugOverLay(); Show4LineDebugOverLay(); //setup RenderTargetListenerDirector mRTListener = new RenderTargetListenerDirector(); mRTListener.SubscribeEvents(); mRTListener.evtPreRenderTargetUpdate += new RenderTargetListenerDirector.RTLD_Delegate_RenderTargetUpdate(event_PreRenderTargetUpdate); mRTListener.evtPostRenderTargetUpdate += new RenderTargetListenerDirector.RTLD_Delegate_RenderTargetUpdate(event_PostRenderTargetUpdate); mSceneManager.SetAmbientLight(Converter.GetColor(0.2f, 0.2f, 0.2f)); mSceneManager.SetSkyBox(true, "Examples/MorningSkyBox"); // Create a light Light l = mSceneManager.CreateLight("MainLight"); l.SetLightType(OgreDotNet.Light.LightTypes.Directional); Math3D.Vector3 dir = new Vector3(0.5f, -1.0f, 0.0f); dir.Normalize(); l.SetDirection(dir); l.SetDiffuseColour(1.0f, 1.0f, 0.8f); l.SetSpecularColour(1.0f, 1.0f, 1.0f); // Create a prefab plane mPlane = new MovablePlane("ReflectPlane"); mPlane.D = 0; mPlane.Normal = OgreVector3.FromVector3(Math3D.Vector3.UnitY); MeshManager.GetSingleton().CreatePlane("ReflectionPlane", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME, mPlane, 2000, 2000, 1, 1, true, 1, 1, 1, Vector3.UnitZ); mPlaneEnt = mSceneManager.CreateEntity("Plane", "ReflectionPlane"); // Create an entity from a model (will be loaded automatically) Entity knotEnt = mSceneManager.CreateEntity("Knot", "knot.mesh"); // Create an entity from a model (will be loaded automatically) Entity ogreHead = mSceneManager.CreateEntity("Head", "ogrehead.mesh"); knotEnt.SetMaterialName("Examples/TextureEffect2"); // Attach the rtt entity to the root of the scene SceneNode rootNode = mSceneManager.GetRootSceneNode(); mPlaneNode = rootNode.CreateChildSceneNode(); // Attach both the plane entity, and the plane definition mPlaneNode.AttachObject(mPlaneEnt); //multi Inheritence problem, use the static Get*From function to convert MovableObject mo = MovableObject.GetMovableObjectFrom(mPlane); mPlaneNode.AttachObject(mo); mPlaneNode.Translate(0.0f, -10.0f, 0.0f); // Tilt it a little to make it interesting //mPlaneNode.Roll( new Radian( new Degree( 5.0f)) ); mPlaneNode.Roll(5.0f); rootNode.CreateChildSceneNode("Head").AttachObject(ogreHead); RenderTexture rttTex = mRoot.GetRenderSystem().CreateRenderTexture("RttTex", 512, 512, TextureType.TEX_TYPE_2D, PixelFormat.PF_R8G8B8); { //new scope for some reason mReflectCam = mSceneManager.CreateCamera("ReflectCam"); mReflectCam.SetNearClipDistance(mCamera.GetNearClipDistance()); mReflectCam.SetFarClipDistance(mCamera.GetFarClipDistance()); mReflectCam.SetAspectRatio( (float)mRenderWindow.GetViewport(0).ActualWidth / (float)mRenderWindow.GetViewport(0).ActualHeight); Viewport v = rttTex.AddViewport(mReflectCam); v.ClearEveryFrame = true; v.BackgroundColor = System.Drawing.Color.Black; //Converter.ToColor( ColourValue.Black ); ResourcePtr resPtr = MaterialManager.Instance.Create("RttMat", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME); MaterialPtr mat = new MaterialPtr(ResourcePtr.getCPtr(resPtr).Handle, false); TextureUnitState t = mat.Get().GetTechnique(0).getPass(0).createTextureUnitState("RustedMetal.jpg"); t = mat.Get().GetTechnique(0).getPass(0).createTextureUnitState("RttTex"); // Blend with base texture t.setColourOperationEx(LayerBlendOperationEx.LBX_BLEND_MANUAL, LayerBlendSource.LBS_TEXTURE, LayerBlendSource.LBS_CURRENT, Color.White, Color.White, 0.25f); t.SetTextureAddressingMode(TextureUnitState.TextureAddressingMode.TAM_CLAMP); t.setProjectiveTexturing(true, mReflectCam); rttTex.AddListener(mRTListener); // set up linked reflection mReflectCam.EnableReflection(mPlane); // Also clip mReflectCam.EnableCustomNearClipPlane(mPlane); } // Give the plane a texture mPlaneEnt.SetMaterialName("RttMat"); // Add a whole bunch of extra transparent entities Entity cloneEnt; for (int n = 0; n < 10; ++n) { // Create a new node under the root SceneNode node = mSceneManager.CreateSceneNode(); // Random translate Vector3 nodePos; nodePos.x = OgreMath.SymmetricRandom() * 750.0f; nodePos.y = OgreMath.SymmetricRandom() * 100.0f + 25.0f; nodePos.z = OgreMath.SymmetricRandom() * 750.0f; node.SetPosition(nodePos); rootNode.AddChild(node); // Clone knot string cloneName = string.Format("Knot{0}", n); cloneEnt = knotEnt.Clone(cloneName); // Attach to new node node.AttachObject(cloneEnt); } mCamera.SetPosition(new Vector3(-50.0f, 100.0f, 500.0f)); mCamera.LookAt = new Vector3(0, 0, 0); }
public static void MOVE_OBJECT_PHY_EX(MovableObject obj, string fileName, Vector3 startPos, Vector3 targetPos, float onceLength, bool loop, KeyFrameCallback TremblingCallBack, KeyFrameCallback TrembleDoneCallBack) { MOVE_OBJECT_PHY_EX(obj, fileName, startPos, targetPos, onceLength, loop, 0.0f, TremblingCallBack, TrembleDoneCallBack); }
public void AddObject(MovableObject movableObject) { objects.Add(movableObject); }
public static void ROTATE_OBJECT(MovableObject obj, string keyframe, Vector3 start, Vector3 target, float onceLength, bool loop, float offset) { ROTATE_OBJECT_EX(obj, keyframe, start, target, onceLength, loop, offset, null, null); }
public void RemoveObject(MovableObject movableObject) { objects.Remove(movableObject); }
public static CommandMovableObjectMovePhysics MOVE_OBJECT_PHY_DELAY(MovableObject obj, float delayTime, string keyframe, Vector3 startPos, Vector3 targetPos, float onceLength, bool loop, float offset) { return(MOVE_OBJECT_PHY_DELAY_EX(obj, delayTime, keyframe, startPos, targetPos, onceLength, loop, offset, null, null)); }
public void Use(MovableObject objectType) { }
public static void TRACK_TARGET(MovableObject obj, float speed, MovableObject target, Vector3 offset) { TRACK_TARGET(obj, speed, target, offset, null); }
public void setLinkObject(MovableObject obj) { mLinkObject = obj; }
public static void ROTATE_SPEED_OBJECT(MovableObject obj, Vector3 speed) { ROTATE_SPEED_OBJECT(obj, speed, Vector3.zero, Vector3.zero); }
public static CommandMovableObjectRotateSpeed ROTATE_SPEED_OBJECT_DELAY(MovableObject obj, float delayTime, Vector3 speed) { return(ROTATE_SPEED_OBJECT_DELAY(obj, delayTime, speed, Vector3.zero, Vector3.zero)); }
void TrackMeshObject_AddToRenderQueue( MovableObject sender, Camera camera, bool onlyShadowCasters, ref bool allowRender ) { float renderTime = RendererWorld.Instance.FrameRenderTime; if( tracksTextureAnimationRenderTime != renderTime ) { tracksTextureAnimationRenderTime = renderTime; UpdateTracksTextureAnimation(); } }
public static CommandMovableObjectRotatePhysics ROTATE_OBJECT_PHY_DELAY(MovableObject obj, float delayTime, Vector3 start, Vector3 target, float time) { return(ROTATE_OBJECT_PHY_DELAY(obj, delayTime, CommonDefine.ZERO_ONE, start, target, time, false, 0.0f)); }
/// <summary> /// Checks if player can controls selected group. If the group is new so the function remove /// all object from their actual groups and recount them. Finally call Select (count bonuses, etc.) /// </summary> /// <param Name="clickedPoint">The mouse position.</param> /// <param name="hitObject">The result of a HitTest.</param> /// <param name="isFriendly">The information if the hitted object is friendly.</param> /// <param name="isMovableGameObject">The information if the hitted object is movable.</param> /// <returns>Returns group answer collected from each member of group</returns> public ActionAnswer SelectInfoGroup(Mogre.Vector3 clickedPoint, MovableObject hitObject, bool isFriendly, bool isMovableGameObject) { if (targetedMgr.TargetedIsMovable) { GroupMovables group = targetedMgr.GetActiveMovableGroup(); if (group.Team.Name == Game.PlayerName) { // All members of group can die so movable group is deactive. if (group.Count == 0) { targetedMgr.Clear(); return ActionAnswer.None; } // Check if actual group is selectedGroupM if (!(imgoGroupDict.ContainsKey(group[0]) && group == imgoGroupDict[group[0]])) { // Group is unselect var toRecount = new List<GroupMovables>(); foreach (IMovableGameObject imgo in group) { if (imgoGroupDict.ContainsKey(imgo)) { // Add object to toRecount if (!toRecount.Contains(imgoGroupDict[imgo])) { toRecount.Add(imgoGroupDict[imgo]); } // Remove from old group and set new oneto Dict imgoGroupDict[imgo].RemoveMember(imgo); imgoGroupDict[imgo] = group; } else { imgoGroupDict.Add(imgo, group); } } // Recount all modified groups foreach (var groupRec in toRecount) { // Recount just basic bonuses, others are removed when the source of them is removed. groupRec.CountBasicBonuses(); } group.Select(); } return group.OnMouseAction(clickedPoint, hitObject, isFriendly, isMovableGameObject); } } return ActionAnswer.None; }
public static CommandMovableObjectRotatePhysics ROTATE_OBJECT_PHY_DELAY(MovableObject obj, float delayTime, string keyframe, Vector3 start, Vector3 target, float onceLength, bool loop) { return(ROTATE_OBJECT_PHY_DELAY(obj, delayTime, keyframe, start, target, onceLength, loop, 0.0f)); }
void OnFocusedControllableMoved(MovableObject ob, ContainerObject dst, IntPoint3 loc) { this.MapControl.FocusedTileView.SetTarget(ob.Environment, ob.Location); }
public static void ROTATE_SPEED_OBJECT_PHY(MovableObject obj) { ROTATE_SPEED_OBJECT(obj, Vector3.zero, Vector3.zero, Vector3.zero); }
public void setThrower(MovableObject thrower) { if (thrower is Enemy) { isEnemyObject = true; } else { isEnemyObject = false; } this.thrower = thrower; }
internal static void selectUnit(MovableObject obj) { if (obj.MovableType == "OgreTerrainNodeMovable" || obj.MovableType == "Camera" || obj.MovableType == "TerrainMipMap") return; GameUnit d = FindOwningUnit(obj.ParentSceneNode); if (d.sceneNode != null) { d.sceneNode.ShowBoundingBox = true; selectedUnits.Add(d); } }