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);
}
}
