path: root/indra/llinventory/llparcel.h

/** 
 * @file llparcel.h
 *
 * $LicenseInfo:firstyear=2002&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLPARCEL_H
#define LL_LLPARCEL_H

#include <time.h>
#include <iostream>

#include "lluuid.h"
#include "llparcelflags.h"
#include "llpermissions.h"
#include "lltimer.h"
#include "v3math.h"
#include "llsettingsdaycycle.h"

// Grid out of which parcels taken is stepped every 4 meters.
const F32 PARCEL_GRID_STEP_METERS	= 4.f;

// Area of one "square" of parcel
const S32 PARCEL_UNIT_AREA			= 16;

// Height _above_ground_ that parcel boundary ends
const F32 PARCEL_HEIGHT = 50.f;

//Height above ground which parcel boundries exist for explicitly banned avatars
const F32 BAN_HEIGHT = 5000.f;

// Maximum number of entries in an access list
const S32 PARCEL_MAX_ACCESS_LIST = 300;
//Maximum number of entires in an update packet
//for access/ban lists.
const F32 PARCEL_MAX_ENTRIES_PER_PACKET = 48.f;

// Maximum number of experiences
const S32 PARCEL_MAX_EXPERIENCE_LIST = 24;

// Weekly charge for listing a parcel in the directory
const S32 PARCEL_DIRECTORY_FEE = 30;

const S32 PARCEL_PASS_PRICE_DEFAULT = 10;
const F32 PARCEL_PASS_HOURS_DEFAULT = 1.f;

// Number of "chunks" in which parcel overlay data is sent
// Chunk 0 = southern rows, entire width
const S32 PARCEL_OVERLAY_CHUNKS = 4;

// Bottom three bits are a color index for the land overlay
const U8 PARCEL_COLOR_MASK	= 0x07;
const U8 PARCEL_PUBLIC		= 0x00;
const U8 PARCEL_OWNED		= 0x01;
const U8 PARCEL_GROUP		= 0x02;
const U8 PARCEL_SELF		= 0x03;
const U8 PARCEL_FOR_SALE	= 0x04;
const U8 PARCEL_AUCTION		= 0x05;
// unused 0x06
// unused 0x07
// flag, unused 0x08
const U8 PARCEL_HIDDENAVS   = 0x10;	// avatars not visible outside of parcel.  Used for 'see avs' feature, but must be off for compatibility
const U8 PARCEL_SOUND_LOCAL = 0x20;
const U8 PARCEL_WEST_LINE	= 0x40;	// flag, property line on west edge
const U8 PARCEL_SOUTH_LINE	= 0x80;	// flag, property line on south edge

// Transmission results for parcel properties
const S32 PARCEL_RESULT_NO_DATA = -1;
const S32 PARCEL_RESULT_SUCCESS = 0;	// got exactly one parcel
const S32 PARCEL_RESULT_MULTIPLE = 1;	// got multiple parcels

const S32 SELECTED_PARCEL_SEQ_ID = -10000;
const S32 COLLISION_NOT_IN_GROUP_PARCEL_SEQ_ID =  -20000;
const S32 COLLISION_BANNED_PARCEL_SEQ_ID = -30000;
const S32 COLLISION_NOT_ON_LIST_PARCEL_SEQ_ID =  -40000;
const S32 HOVERED_PARCEL_SEQ_ID =  -50000;

const U32 RT_NONE	= 0x1 << 0;
const U32 RT_OWNER	= 0x1 << 1;
const U32 RT_GROUP	= 0x1 << 2;
const U32 RT_OTHER	= 0x1 << 3;
const U32 RT_LIST	= 0x1 << 4;
const U32 RT_SELL	= 0x1 << 5;

const S32 INVALID_PARCEL_ID = -1;

const S32 INVALID_PARCEL_ENVIRONMENT_VERSION = -2;
// if Region settings are used, parcel env. version is -1
const S32 UNSET_PARCEL_ENVIRONMENT_VERSION = -1;

// Timeouts for parcels
// default is 21 days * 24h/d * 60m/h * 60s/m *1000000 usec/s = 1814400000000
const U64 DEFAULT_USEC_CONVERSION_TIMEOUT = U64L(1814400000000);
// ***** TESTING is 10 minutes
//const U64 DEFAULT_USEC_CONVERSION_TIMEOUT = U64L(600000000);

// group is 60 days * 24h/d * 60m/h * 60s/m *1000000 usec/s = 5184000000000
const U64 GROUP_USEC_CONVERSION_TIMEOUT = U64L(5184000000000);
// ***** TESTING is 10 minutes
//const U64 GROUP_USEC_CONVERSION_TIMEOUT = U64L(600000000);

// default sale timeout is 2 days -> 172800000000
const U64 DEFAULT_USEC_SALE_TIMEOUT = U64L(172800000000);
// ***** TESTING is 10 minutes
//const U64 DEFAULT_USEC_SALE_TIMEOUT = U64L(600000000);

// more grace period extensions.
const U64 SEVEN_DAYS_IN_USEC = U64L(604800000000);

// if more than 100,000s before sale revert, and no extra extension
// has been given, go ahead and extend it more. That's about 1.2 days.
const S32 EXTEND_GRACE_IF_MORE_THAN_SEC = 100000;



class LLMessageSystem;
class LLSD;

class LLAccessEntry
{
public:

	typedef std::map<LLUUID,LLAccessEntry> map;

	LLAccessEntry()
	:	mTime(0),
		mFlags(0)
	{}

	LLUUID		mID;		// Agent ID
	S32			mTime;		// Time (unix seconds) when entry expires
	U32			mFlags;		// Not used - currently should always be zero
};


class LLParcel
{
public:
	enum EOwnershipStatus
	{
		OS_LEASED = 0,
		OS_LEASE_PENDING = 1,
		OS_ABANDONED = 2,
		OS_COUNT = 3,
		OS_NONE = -1
	};
	enum ECategory
	{
		C_NONE = 0,
		C_LINDEN,
		C_ADULT,
		C_ARTS,			// "arts & culture"
		C_BUSINESS,		// was "store"
		C_EDUCATIONAL,
		C_GAMING,		// was "game"
		C_HANGOUT,		// was "gathering place"
		C_NEWCOMER,
		C_PARK,			// "parks & nature"
		C_RESIDENTIAL,	// was "homestead"
		C_SHOPPING,
		C_STAGE,
		C_OTHER,
		C_RENTAL,
		C_COUNT,
		C_ANY = -1		// only useful in queries
	};
	enum EAction
	{
		A_CREATE = 0,
		A_RELEASE = 1,
		A_ABSORB = 2,
		A_ABSORBED = 3,
		A_DIVIDE = 4,
		A_DIVISION = 5,
		A_ACQUIRE = 6,
		A_RELINQUISH = 7,
		A_CONFIRM = 8,
		A_COUNT = 9,
		A_UNKNOWN = -1
	};

	enum ELandingType
	{
		L_NONE = 0,
		L_LANDING_POINT = 1,
		L_DIRECT = 2
	};

	// CREATORS
	LLParcel();
	LLParcel(
		const LLUUID &owner_id,
		bool modify,
		bool terraform,
		bool damage,
		time_t claim_date,
		S32 claim_price,
		S32 rent_price,
		S32 area,
		S32 sim_object_limit,
		F32 parcel_object_bonus,
		bool is_group_owned = false);
	virtual ~LLParcel();

	void init(
		const LLUUID &owner_id,
		bool modify,
		bool terraform,
		bool damage,
		time_t claim_date,
		S32 claim_price,
		S32 rent_price,
		S32 area,
		S32 sim_object_limit,
		F32 parcel_object_bonus,
		bool is_group_owned = false);

	// TODO: make an actual copy constructor for this
	void overrideParcelFlags(U32 flags);
	// if you specify an agent id here, the group id will be zeroed
	void overrideOwner(
		const LLUUID& owner_id,
		bool is_group_owned = false);
	void overrideSaleTimerExpires(F32 secs_left) { mSaleTimerExpires.setTimerExpirySec(secs_left); }

	// MANIPULATORS
	void generateNewID() { mID.generate(); }
	void setName(const std::string& name);
	void setDesc(const std::string& desc);
	void setMusicURL(const std::string& url);
	void setMediaURL(const std::string& url);
	void setMediaType(const std::string& type);
	void setMediaDesc(const std::string& desc);
	void	setMediaID(const LLUUID& id) { mMediaID = id; }
	void	setMediaAutoScale ( U8 flagIn ) { mMediaAutoScale = flagIn; }
	void    setMediaLoop (U8 loop) { mMediaLoop = loop; }
	void setMediaWidth(S32 width);
	void setMediaHeight(S32 height);
	void setMediaCurrentURL(const std::string& url);
	void setMediaAllowNavigate(U8 enable) { mMediaAllowNavigate = enable; }
	void setMediaURLTimeout(F32 timeout) { mMediaURLTimeout = timeout; }
	void setMediaPreventCameraZoom(U8 enable) { mMediaPreventCameraZoom = enable; }

	void setMediaURLResetTimer(F32 time);
	virtual void	setLocalID(S32 local_id);

	// blow away all the extra stuff lurking in parcels, including urls, access lists, etc
	void clearParcel();

	// This value is not persisted out to the parcel file, it is only
	// a per-process blocker for attempts to purchase.
	void setInEscrow(bool in_escrow) { mInEscrow = in_escrow; }

	void setAuthorizedBuyerID(const LLUUID& id) { mAuthBuyerID = id; }
	//void overrideBuyerID(const LLUUID& id) { mBuyerID = id; }
	void setCategory(ECategory category) { mCategory = category; }
	void setSnapshotID(const LLUUID& id) { mSnapshotID = id; }
	void setUserLocation(const LLVector3& pos)	{ mUserLocation = pos; }
	void setUserLookAt(const LLVector3& rot)	{ mUserLookAt = rot; }
	void setLandingType(const ELandingType type) { mLandingType = type; }
	void setSeeAVs(bool see_avs)	{ mSeeAVs = see_avs;	}
	void setHaveNewParcelLimitData(bool have_new_parcel_data)		{ mHaveNewParcelLimitData = have_new_parcel_data;		}		// Remove this once hidden AV feature is fully available grid-wide

	void setAuctionID(U32 auction_id) { mAuctionID = auction_id;}

	void	setAllParcelFlags(U32 flags);
	void	setParcelFlag(U32 flag, bool b);

	virtual void setArea(S32 area, S32 sim_object_limit);
	void	setDiscountRate(F32 rate);

	void	setAllowModify(bool b)	{ setParcelFlag(PF_CREATE_OBJECTS, b); }
	void	setAllowGroupModify(bool b)	{ setParcelFlag(PF_CREATE_GROUP_OBJECTS, b); }
	void	setAllowAllObjectEntry(bool b)	{ setParcelFlag(PF_ALLOW_ALL_OBJECT_ENTRY, b); }
	void	setAllowGroupObjectEntry(bool b)	{ setParcelFlag(PF_ALLOW_GROUP_OBJECT_ENTRY, b); }
	void	setAllowTerraform(bool b){setParcelFlag(PF_ALLOW_TERRAFORM, b); }
	void	setAllowDamage(bool b)	{ setParcelFlag(PF_ALLOW_DAMAGE, b); }
	void	setAllowFly(bool b)		{ setParcelFlag(PF_ALLOW_FLY, b); }
	void	setAllowGroupScripts(bool b)	{ setParcelFlag(PF_ALLOW_GROUP_SCRIPTS, b); }
	void	setAllowOtherScripts(bool b)	{ setParcelFlag(PF_ALLOW_OTHER_SCRIPTS, b); }
	void	setAllowDeedToGroup(bool b) { setParcelFlag(PF_ALLOW_DEED_TO_GROUP, b); }
	void    setContributeWithDeed(bool b) { setParcelFlag(PF_CONTRIBUTE_WITH_DEED, b); }
	void	setForSale(bool b)		{ setParcelFlag(PF_FOR_SALE, b); }
	void	setSoundOnly(bool b)	{ setParcelFlag(PF_SOUND_LOCAL, b); }
	void	setDenyAnonymous(bool b) { setParcelFlag(PF_DENY_ANONYMOUS, b); }
	void	setDenyAgeUnverified(bool b) { setParcelFlag(PF_DENY_AGEUNVERIFIED, b); }
	void	setRestrictPushObject(bool b) { setParcelFlag(PF_RESTRICT_PUSHOBJECT, b); }
	void	setAllowGroupAVSounds(bool b)	{ mAllowGroupAVSounds = b;		}
	void	setAllowAnyAVSounds(bool b)		{ mAllowAnyAVSounds = b;		}
    void    setObscureMOAP(bool b)  { mObscureMOAP = b; }

	void	setDrawDistance(F32 dist)	{ mDrawDistance = dist; }
	void	setSalePrice(S32 price)		{ mSalePrice = price; }
	void	setGroupID(const LLUUID& id)	{ mGroupID = id; }
	//void	setGroupName(const std::string& s)	{ mGroupName.assign(s); }
	void	setPassPrice(S32 price)				{ mPassPrice = price; }
	void	setPassHours(F32 hours)				{ mPassHours = hours; }

//	bool	importStream(std::istream& input_stream);
	bool	importAccessEntry(std::istream& input_stream, LLAccessEntry* entry);
	// bool	exportStream(std::ostream& output_stream);

	void	packMessage(LLMessageSystem* msg);
	void	packMessage(LLSD& msg);
	void	unpackMessage(LLMessageSystem* msg);

	void	packAccessEntries(LLMessageSystem* msg,
								const std::map<LLUUID,LLAccessEntry>& list);
	void	unpackAccessEntries(LLMessageSystem* msg,
								std::map<LLUUID,LLAccessEntry>* list);

	void	unpackExperienceEntries(LLMessageSystem* msg, U32 type);


	void	setAABBMin(const LLVector3& min)	{ mAABBMin = min; }
	void	setAABBMax(const LLVector3& max)	{ mAABBMax = max; }

	// Extend AABB to include rectangle from min to max.
	void extendAABB(const LLVector3& box_min, const LLVector3& box_max);

	void dump();

	// Scans the pass list and removes any items with an expiration
	// time earlier than "now".
	void expirePasses(S32 now);

	// Add to list, suppressing duplicates.  Returns true if added.
	bool addToAccessList(const LLUUID& agent_id, S32 time);
	bool addToBanList(const LLUUID& agent_id, S32 time);
	bool removeFromAccessList(const LLUUID& agent_id);
	bool removeFromBanList(const LLUUID& agent_id);

	// ACCESSORS
	const LLUUID&	getID() const				{ return mID; }
	const std::string&	getName() const			{ return mName; }
	const std::string&	getDesc() const			{ return mDesc; }
	const std::string&	getMusicURL() const		{ return mMusicURL; }
	const std::string&	getMediaURL() const		{ return mMediaURL; }
	const std::string&	getMediaDesc() const	{ return mMediaDesc; }
	const std::string&	getMediaType() const	{ return mMediaType; }
	const LLUUID&	getMediaID() const			{ return mMediaID; }
	S32				getMediaWidth() const		{ return mMediaWidth; }
	S32				getMediaHeight() const		{ return mMediaHeight; }
	U8				getMediaAutoScale() const	{ return mMediaAutoScale; }
	U8              getMediaLoop() const        { return mMediaLoop; }
	const std::string&  getMediaCurrentURL() const { return mMediaCurrentURL; }
	U8              getMediaAllowNavigate() const { return mMediaAllowNavigate; }
	F32				getMediaURLTimeout() const { return mMediaURLTimeout; }
	U8              getMediaPreventCameraZoom() const { return mMediaPreventCameraZoom; }

	S32				getLocalID() const			{ return mLocalID; }
	const LLUUID&	getOwnerID() const			{ return mOwnerID; }
	const LLUUID&	getGroupID() const			{ return mGroupID; }
	S32				getPassPrice() const		{ return mPassPrice; }
	F32				getPassHours() const		{ return mPassHours; }
	bool			getIsGroupOwned() const		{ return mGroupOwned; }

	U32 getAuctionID() const	{ return mAuctionID; }
	bool isInEscrow() const		{ return mInEscrow; }

	bool isPublic() const;

	// Region-local user-specified position
	const LLVector3& getUserLocation() const	{ return mUserLocation; }
	const LLVector3& getUserLookAt() const	{ return mUserLookAt; }
	ELandingType getLandingType() const	{ return mLandingType; }
	bool getSeeAVs() const			{ return mSeeAVs;		}
	bool getHaveNewParcelLimitData() const		{ return mHaveNewParcelLimitData;	}

	// User-specified snapshot
	const LLUUID&	getSnapshotID() const		{ return mSnapshotID; }

	// the authorized buyer id is the person who is the only
	// agent/group that has authority to purchase. (ie, ui specified a
	// particular agent could buy the plot).
	const LLUUID& getAuthorizedBuyerID() const { return mAuthBuyerID; }

	// helper function
	bool isBuyerAuthorized(const LLUUID& buyer_id) const;

	// The buyer of a plot is set when someone indicates they want to
	// buy the plot, and the system is simply waiting for tier-up
	// approval
	//const LLUUID& getBuyerID() const { return mBuyerID; }

	// functions to deal with ownership status.
	EOwnershipStatus getOwnershipStatus() const { return mStatus; }
	static const std::string& getOwnershipStatusString(EOwnershipStatus status);
	void setOwnershipStatus(EOwnershipStatus status) { mStatus = status; }

	// dealing with parcel category information
	ECategory getCategory() const {return mCategory; }
	static const std::string& getCategoryString(ECategory category);
	static const std::string& getCategoryUIString(ECategory category);
	static ECategory getCategoryFromString(const std::string& string);
	static ECategory getCategoryFromUIString(const std::string& string);

	// functions for parcel action (used for logging)
	static const std::string& getActionString(EAction action);

	// dealing with sales and parcel conversion.
	//
	// the isSaleTimerExpired will trivially return false if there is
	// no sale going on. Pass in the current time in usec which will
	// be used for comparison.
	bool isSaleTimerExpired(const U64& time);

	F32 getSaleTimerExpires() { return mSaleTimerExpires.getRemainingTimeF32(); }

	// should the parcel join on complete?
	//U32 getJoinNeighbors() const { return mJoinNeighbors; }

	// need to record a few things with the parcel when a sale
	// starts.
	void startSale(const LLUUID& buyer_id, bool is_buyer_group);

	// do the expiration logic, which needs to return values usable in
	// a L$ transaction.
	void expireSale(U32& type, U8& flags, LLUUID& from_id, LLUUID& to_id);
	void completeSale(U32& type, U8& flags, LLUUID& to_id);
	void clearSale();


	bool isMediaResetTimerExpired(const U64& time);


	// more accessors
	U32		getParcelFlags() const { return mParcelFlags; }

	bool	getParcelFlag(U32 flag) const { return (mParcelFlags & flag) != 0; }

	// objects can be added or modified by anyone (only parcel owner if disabled)
	bool	getAllowModify() const                     { return getParcelFlag(PF_CREATE_OBJECTS); }

	// objects can be added or modified by group members
	bool	getAllowGroupModify() const                { return getParcelFlag(PF_CREATE_GROUP_OBJECTS); }

	// the parcel can be deeded to the group
	bool	getAllowDeedToGroup() const                { return getParcelFlag(PF_ALLOW_DEED_TO_GROUP); }

	// Does the owner want to make a contribution along with the deed.
	bool	getContributeWithDeed() const              { return getParcelFlag(PF_CONTRIBUTE_WITH_DEED); }

	// heightfield can be modified
	bool	getAllowTerraform() const                  { return getParcelFlag(PF_ALLOW_TERRAFORM); }

	// avatars can be hurt here
	bool	getAllowDamage() const                     { return getParcelFlag(PF_ALLOW_DAMAGE); }

	bool	getAllowFly() const                        { return getParcelFlag(PF_ALLOW_FLY); }
	bool	getAllowGroupScripts() const               { return getParcelFlag(PF_ALLOW_GROUP_SCRIPTS); }
	bool	getAllowOtherScripts() const               { return getParcelFlag(PF_ALLOW_OTHER_SCRIPTS); }
	bool	getAllowAllObjectEntry() const             { return getParcelFlag(PF_ALLOW_ALL_OBJECT_ENTRY); }
	bool	getAllowGroupObjectEntry() const           { return getParcelFlag(PF_ALLOW_GROUP_OBJECT_ENTRY); }
	bool	getForSale() const                         { return getParcelFlag(PF_FOR_SALE); }
	bool	getSoundLocal() const                      { return getParcelFlag(PF_SOUND_LOCAL); }
	bool	getParcelFlagAllowVoice() const            { return getParcelFlag(PF_ALLOW_VOICE_CHAT); }
	bool	getParcelFlagUseEstateVoiceChannel() const { return getParcelFlag(PF_USE_ESTATE_VOICE_CHAN); }
	bool	getAllowPublish() const                    { return getParcelFlag(PF_ALLOW_PUBLISH); }
	bool	getMaturePublish() const                   { return getParcelFlag(PF_MATURE_PUBLISH); }
	bool	getRestrictPushObject() const              { return getParcelFlag(PF_RESTRICT_PUSHOBJECT); }

	bool	getRegionPushOverride() const              { return mRegionPushOverride; }
	bool	getRegionDenyAnonymousOverride() const     { return mRegionDenyAnonymousOverride; }
	bool	getRegionDenyAgeUnverifiedOverride() const { return mRegionDenyAgeUnverifiedOverride; }
    bool    getRegionAllowAccessOverride() const       { return mRegionAllowAccessoverride; }
    bool    getRegionAllowEnvironmentOverride() const  { return mRegionAllowEnvironmentOverride; }
    S32     getParcelEnvironmentVersion() const        { return mCurrentEnvironmentVersion; }
	bool	getAllowGroupAVSounds() const              { return mAllowGroupAVSounds; }
	bool	getAllowAnyAVSounds() const	               { return mAllowAnyAVSounds; }
	bool	getObscureMOAP() const                     { return mObscureMOAP; }

	F32		getDrawDistance() const			{ return mDrawDistance; }
	S32		getSalePrice() const			{ return mSalePrice; }
	time_t	getClaimDate() const			{ return mClaimDate; }
	S32		getClaimPricePerMeter() const	{ return mClaimPricePerMeter; }
	S32		getRentPricePerMeter() const	{ return mRentPricePerMeter; }

	// Area is NOT automatically calculated.  You must calculate it
	// and store it with setArea.
	S32		getArea() const					{ return mArea; }

	// deprecated 12/11/2003
	//F32		getDiscountRate() const			{ return mDiscountRate; }

	S32		getClaimPrice() const			{ return mClaimPricePerMeter * mArea; }

	// Can this agent create objects here?
	bool	allowModifyBy(const LLUUID &agent_id, const LLUUID &group_id) const;

	// Can this agent change the shape of the land?
	bool	allowTerraformBy(const LLUUID &agent_id) const;

	bool	operator==(const LLParcel &rhs) const;

	// Calculate rent - area * rent * discount rate
	S32		getTotalRent() const;
	F32		getAdjustedRentPerMeter() const;

	const LLVector3&	getAABBMin() const		{ return mAABBMin; }
	const LLVector3&	getAABBMax() const		{ return mAABBMax; }
	LLVector3 getCenterpoint() const;

	// simwide
	S32		getSimWideMaxPrimCapacity() const { return mSimWideMaxPrimCapacity; }
	S32 getSimWidePrimCount() const { return mSimWidePrimCount; }

	// this parcel only (not simwide)
	S32		getMaxPrimCapacity() const	{ return mMaxPrimCapacity; }	// Does not include prim bonus
	S32		getPrimCount() const		{ return mOwnerPrimCount + mGroupPrimCount + mOtherPrimCount + mSelectedPrimCount; }
	S32		getOwnerPrimCount() const	{ return mOwnerPrimCount; }
	S32		getGroupPrimCount() const	{ return mGroupPrimCount; }
	S32		getOtherPrimCount() const	{ return mOtherPrimCount; }
	S32		getSelectedPrimCount() const{ return mSelectedPrimCount; }
	S32		getTempPrimCount() const	{ return mTempPrimCount; }
	F32		getParcelPrimBonus() const	{ return mParcelPrimBonus; }

	S32		getCleanOtherTime() const			{ return mCleanOtherTime; }

	void	setMaxPrimCapacity(S32 max) { mMaxPrimCapacity = max; }		// Does not include prim bonus
	// simwide
	void	setSimWideMaxPrimCapacity(S32 current)	{ mSimWideMaxPrimCapacity = current; }
	void setSimWidePrimCount(S32 current) { mSimWidePrimCount = current; }

	// this parcel only (not simwide)
	void	setOwnerPrimCount(S32 current)	{ mOwnerPrimCount = current; }
	void	setGroupPrimCount(S32 current)	{ mGroupPrimCount = current; }
	void	setOtherPrimCount(S32 current)	{ mOtherPrimCount = current; }
	void	setSelectedPrimCount(S32 current)	{ mSelectedPrimCount = current; }
	void	setTempPrimCount(S32 current)	{ mTempPrimCount = current; }
	void	setParcelPrimBonus(F32 bonus) 	{ mParcelPrimBonus = bonus; }

	void	setCleanOtherTime(S32 time)					{ mCleanOtherTime = time; }
	void	setRegionPushOverride(bool override) {mRegionPushOverride = override; }
	void	setRegionDenyAnonymousOverride(bool override)	{ mRegionDenyAnonymousOverride = override; }
	void	setRegionDenyAgeUnverifiedOverride(bool override)	{ mRegionDenyAgeUnverifiedOverride = override; }
    void    setRegionAllowAccessOverride(bool override) { mRegionAllowAccessoverride = override; }
    void    setRegionAllowEnvironmentOverride(bool override) { mRegionAllowEnvironmentOverride = override; }

    void    setParcelEnvironmentVersion(S32 version) { mCurrentEnvironmentVersion = version; }

	// Accessors for parcel sellWithObjects
	void	setPreviousOwnerID(LLUUID prev_owner)	{ mPreviousOwnerID = prev_owner; }
	void	setPreviouslyGroupOwned(bool b)			{ mPreviouslyGroupOwned = b; }
	void	setSellWithObjects(bool b)				{ setParcelFlag(PF_SELL_PARCEL_OBJECTS, b); }

	LLUUID	getPreviousOwnerID() const		{ return mPreviousOwnerID; }
	bool	getPreviouslyGroupOwned() const	{ return mPreviouslyGroupOwned; }
	bool	getSellWithObjects() const		{ return getParcelFlag(PF_SELL_PARCEL_OBJECTS); }

protected:
	LLUUID mID;
	LLUUID				mOwnerID;
	LLUUID				mGroupID;
	bool				mGroupOwned; // true if mOwnerID is a group_id
	LLUUID				mPreviousOwnerID;
	bool				mPreviouslyGroupOwned;

	EOwnershipStatus mStatus;
	ECategory mCategory;
	LLUUID mAuthBuyerID;
	LLUUID mSnapshotID;
	LLVector3 mUserLocation;
	LLVector3 mUserLookAt;
	ELandingType mLandingType;
	bool mSeeAVs;							// Avatars on this parcel are visible from outside it
	bool mHaveNewParcelLimitData;			// Remove once hidden AV feature is grid-wide
	LLTimer mSaleTimerExpires;
	LLTimer mMediaResetTimer;

	S32 mGraceExtension;

	// This value is non-zero if there is an auction associated with
	// the parcel.
	U32 mAuctionID;

	// value used to temporarily lock attempts to purchase the parcel.
	bool mInEscrow;

	time_t				mClaimDate;				// UTC Unix-format time
	S32					mClaimPricePerMeter;	// meter squared
	S32					mRentPricePerMeter;		// meter squared
	S32					mArea;					// meter squared
	F32					mDiscountRate;			// 0.0-1.0
	F32					mDrawDistance;
	U32					mParcelFlags;
	S32					mSalePrice;				// linden dollars
	std::string			mName;
	std::string			mDesc;
	std::string			mMusicURL;
	std::string			mMediaURL;
	std::string			mMediaDesc;
	std::string 		mMediaType;
	S32					mMediaWidth;
	S32					mMediaHeight;
	U8					mMediaAutoScale;
	U8                  mMediaLoop;
	std::string         mMediaCurrentURL;
	LLUUID				mMediaID;
	U8                  mMediaAllowNavigate;
	U8					mMediaPreventCameraZoom;
	F32					mMediaURLTimeout;
	S32					mPassPrice;
	F32					mPassHours;
	LLVector3			mAABBMin;
	LLVector3			mAABBMax;
	S32					mMaxPrimCapacity;		// Prims allowed on parcel, does not include prim bonus
	S32					mSimWidePrimCount;
	S32					mSimWideMaxPrimCapacity;
	//S32					mSimWidePrimCorrection;
	S32					mOwnerPrimCount;
	S32					mGroupPrimCount;
	S32					mOtherPrimCount;
	S32					mSelectedPrimCount;
	S32					mTempPrimCount;
	F32					mParcelPrimBonus;
	S32					mCleanOtherTime;
	bool				mRegionPushOverride;
	bool				mRegionDenyAnonymousOverride;
	bool				mRegionDenyAgeUnverifiedOverride;
    bool                mRegionAllowAccessoverride;
    bool                mRegionAllowEnvironmentOverride;
	bool				mAllowGroupAVSounds;
	bool				mAllowAnyAVSounds;
    bool                mObscureMOAP;
    S32                 mCurrentEnvironmentVersion;
	
    bool                mIsDefaultDayCycle;

public:
	// HACK, make private
	S32					mLocalID;
	LLUUID			    mBanListTransactionID;
	LLUUID			    mAccessListTransactionID;
	std::map<LLUUID,LLAccessEntry>	mAccessList;
	std::map<LLUUID,LLAccessEntry>	mBanList;
	std::map<LLUUID,LLAccessEntry>	mTempBanList;
	std::map<LLUUID,LLAccessEntry>	mTempAccessList;

	typedef std::map<LLUUID, U32> xp_type_map_t;

	void setExperienceKeyType(const LLUUID& experience_key, U32 type);
	U32 countExperienceKeyType(U32 type);
	LLAccessEntry::map getExperienceKeysByType(U32 type)const;
	void clearExperienceKeysByType(U32 type);

private:
	xp_type_map_t mExperienceKeys;
};


const std::string& ownership_status_to_string(LLParcel::EOwnershipStatus status);
LLParcel::EOwnershipStatus ownership_string_to_status(const std::string& s);
LLParcel::ECategory category_string_to_category(const std::string& s);
const std::string& category_to_string(LLParcel::ECategory category);


#endif