// $Revision: 1.6 $
//Copyright (C) Taligent, Inc. All rights reserved.
#ifndef TaligentSamples_COLLISIONSUBSYSTEM
#include "CollisionSubsystem.h"
#endif

#ifndef TaligentSamples_CONCURRENTACTORS
#include "ConcurrentActors.h"
#endif

//==============================================================================
// TCollisionNotification

MCollectibleDefinitionsMacro(TCollisionNotification, kOriginalVersion);

TCollisionNotification::TCollisionNotification(const TInterest& interest,
	MColliding* object)
	: TNotification(interest), fObject(object)
{
}

TCollisionNotification::TCollisionNotification(TInterest* interest,
	MColliding* object)
	: TNotification(*interest), fObject(object)
{
	delete interest;
}

TCollisionNotification::TCollisionNotification(
	const TCollisionNotification& source) 
	: TNotification(source), fObject(source.fObject)
{
}

TCollisionNotification::~TCollisionNotification()
{
}

TCollisionNotification&			
TCollisionNotification::operator=(const TCollisionNotification& source)
{
	if (&source != this) {
		TNotification::operator=(source);
		fObject = source.fObject;
	}
	return *this;
}

bool			
TCollisionNotification::IsEqual(const MCollectible* other) const
{
	bool result(true);

	if (this == other) {
		result = true;
	} 
	else if (!TNotification::IsEqual(other)) {
		result = false;
	} 
	else {
		const TCollisionNotification* otherTCollisionNotification = 
			(const TCollisionNotification*)other;
		return fObject == otherTCollisionNotification->fObject;
	}
	return result;
}

long			
TCollisionNotification::Hash() const
{
	return TNotification::Hash() ^ (long)fObject;
}

MColliding*		
TCollisionNotification::GetObject() const
{
	return fObject;
}

TCollisionNotification::TCollisionNotification()
	: TNotification(), fObject(NIL)
{
}

TStream&		
TCollisionNotification::operator>>=(TStream& toStream) const
{
	ERROR("TCollisionNotification::operator>>=");
	return toStream;
}

TStream&		
TCollisionNotification::operator<<=(TStream& fromStream)
{
	ERROR("TCollisionNotification::operator<<=");
	return fromStream;
}

//==============================================================================
// MColliding

TaligentTypeExtensionMacro_Abstract(MColliding)

MColliding::MColliding()
{
}

MColliding::~MColliding()
{
}

bool
MColliding::IsA(const TType& type) const
{
	return type == StaticTypeInfo(MColliding);
}

TInterest*
MColliding::CreateCollisionInterest()
{
	static const TToken kInterestToken("MColliding::CreateCollisionInterest");
	return new TInterest(&GetNotifier(), kInterestToken);
}

void
MColliding::NotifyCollisionPossible()
{
	GetNotifier().Notify(TCollisionNotification(CreateCollisionInterest(), this));
}

//==============================================================================
// TCollisionBehavior

TaligentTypeExtensionMacro_Abstract(TCollisionBehavior)

TCollisionBehavior::TCollisionBehavior()
{
}

TCollisionBehavior::TCollisionBehavior(const TCollisionBehavior& source) 
{
}

TCollisionBehavior::~TCollisionBehavior()
{
}

TCollisionBehavior&		
TCollisionBehavior::operator=(const TCollisionBehavior& source)
{
	return *this;
}

TStream&		
TCollisionBehavior::operator>>=(TStream& toStream) const
{
	WriteVersion(toStream);
	return toStream;
}

TStream&		
TCollisionBehavior::operator<<=(TStream& fromStream)
{
	ReadVersion(fromStream, kOriginalVersion, kOriginalVersion);
	return fromStream;
}