diff options
author | mingchen | 2007-07-16 19:52:46 +0000 |
---|---|---|
committer | mingchen | 2007-07-16 19:52:46 +0000 |
commit | 41b9baa054b135479939528016e31cbad4a9d765 (patch) | |
tree | 3ebf5ccbe6cf5f055493b8e81bc1362e73d93e1c /OpenSim/Region/Environment/LandManagement/Land.cs | |
parent | *Renamed everything Parcels and ParcelData to Land and LandData (diff) | |
download | opensim-SC-41b9baa054b135479939528016e31cbad4a9d765.zip opensim-SC-41b9baa054b135479939528016e31cbad4a9d765.tar.gz opensim-SC-41b9baa054b135479939528016e31cbad4a9d765.tar.bz2 opensim-SC-41b9baa054b135479939528016e31cbad4a9d765.tar.xz |
*Adding some more files
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Region/Environment/LandManagement/Land.cs | 599 |
1 files changed, 599 insertions, 0 deletions
diff --git a/OpenSim/Region/Environment/LandManagement/Land.cs b/OpenSim/Region/Environment/LandManagement/Land.cs new file mode 100644 index 0000000..b333f36 --- /dev/null +++ b/OpenSim/Region/Environment/LandManagement/Land.cs | |||
@@ -0,0 +1,599 @@ | |||
1 | using System; | ||
2 | using System.Collections.Generic; | ||
3 | using libsecondlife; | ||
4 | using libsecondlife.Packets; | ||
5 | using OpenSim.Framework.Interfaces; | ||
6 | using OpenSim.Framework.Types; | ||
7 | using OpenSim.Region.Environment.Scenes; | ||
8 | |||
9 | namespace OpenSim.Region.Environment.LandManagement | ||
10 | { | ||
11 | #region Parcel Class | ||
12 | /// <summary> | ||
13 | /// Keeps track of a specific piece of land's information | ||
14 | /// </summary> | ||
15 | public class Land | ||
16 | { | ||
17 | #region Member Variables | ||
18 | public LandData landData = new LandData(); | ||
19 | public List<SceneObject> primsOverMe = new List<SceneObject>(); | ||
20 | |||
21 | public Scene m_world; | ||
22 | |||
23 | private bool[,] landBitmap = new bool[64, 64]; | ||
24 | |||
25 | #endregion | ||
26 | |||
27 | |||
28 | #region Constructors | ||
29 | public Land(LLUUID owner_id, bool is_group_owned, Scene world) | ||
30 | { | ||
31 | m_world = world; | ||
32 | landData.ownerID = owner_id; | ||
33 | landData.isGroupOwned = is_group_owned; | ||
34 | |||
35 | } | ||
36 | #endregion | ||
37 | |||
38 | |||
39 | #region Member Functions | ||
40 | |||
41 | #region General Functions | ||
42 | /// <summary> | ||
43 | /// Checks to see if this land object contains a point | ||
44 | /// </summary> | ||
45 | /// <param name="x"></param> | ||
46 | /// <param name="y"></param> | ||
47 | /// <returns>Returns true if the piece of land contains the specified point</returns> | ||
48 | public bool containsPoint(int x, int y) | ||
49 | { | ||
50 | if (x >= 0 && y >= 0 && x <= 256 && x <= 256) | ||
51 | { | ||
52 | return (landBitmap[x / 4, y / 4] == true); | ||
53 | } | ||
54 | else | ||
55 | { | ||
56 | return false; | ||
57 | } | ||
58 | } | ||
59 | |||
60 | public Land Copy() | ||
61 | { | ||
62 | Land newLand = new Land(this.landData.ownerID, this.landData.isGroupOwned, m_world); | ||
63 | |||
64 | //Place all new variables here! | ||
65 | newLand.landBitmap = (bool[,])(this.landBitmap.Clone()); | ||
66 | newLand.landData = landData.Copy(); | ||
67 | |||
68 | return newLand; | ||
69 | } | ||
70 | |||
71 | #endregion | ||
72 | |||
73 | |||
74 | #region Packet Request Handling | ||
75 | /// <summary> | ||
76 | /// Sends land properties as requested | ||
77 | /// </summary> | ||
78 | /// <param name="sequence_id">ID sent by client for them to keep track of</param> | ||
79 | /// <param name="snap_selection">Bool sent by client for them to use</param> | ||
80 | /// <param name="remote_client">Object representing the client</param> | ||
81 | public void sendLandProperties(int sequence_id, bool snap_selection, int request_result, IClientAPI remote_client) | ||
82 | { | ||
83 | |||
84 | ParcelPropertiesPacket updatePacket = new ParcelPropertiesPacket(); | ||
85 | updatePacket.ParcelData.AABBMax = landData.AABBMax; | ||
86 | updatePacket.ParcelData.AABBMin = landData.AABBMin; | ||
87 | updatePacket.ParcelData.Area = landData.area; | ||
88 | updatePacket.ParcelData.AuctionID = landData.auctionID; | ||
89 | updatePacket.ParcelData.AuthBuyerID = landData.authBuyerID; //unemplemented | ||
90 | |||
91 | updatePacket.ParcelData.Bitmap = landData.landBitmapByteArray; | ||
92 | |||
93 | updatePacket.ParcelData.Desc = Helpers.StringToField(landData.landDesc); | ||
94 | updatePacket.ParcelData.Category = (byte)landData.category; | ||
95 | updatePacket.ParcelData.ClaimDate = landData.claimDate; | ||
96 | updatePacket.ParcelData.ClaimPrice = landData.claimPrice; | ||
97 | updatePacket.ParcelData.GroupID = landData.groupID; | ||
98 | updatePacket.ParcelData.GroupPrims = landData.groupPrims; | ||
99 | updatePacket.ParcelData.IsGroupOwned = landData.isGroupOwned; | ||
100 | updatePacket.ParcelData.LandingType = (byte)landData.landingType; | ||
101 | updatePacket.ParcelData.LocalID = landData.localID; | ||
102 | if (landData.area > 0) | ||
103 | { | ||
104 | updatePacket.ParcelData.MaxPrims = Convert.ToInt32(Math.Round((Convert.ToDecimal(landData.area) / Convert.ToDecimal(65536)) * 15000 * Convert.ToDecimal(m_world.RegionInfo.estateSettings.objectBonusFactor))); | ||
105 | } | ||
106 | else | ||
107 | { | ||
108 | updatePacket.ParcelData.MaxPrims = 0; | ||
109 | } | ||
110 | updatePacket.ParcelData.MediaAutoScale = landData.mediaAutoScale; | ||
111 | updatePacket.ParcelData.MediaID = landData.mediaID; | ||
112 | updatePacket.ParcelData.MediaURL = Helpers.StringToField(landData.mediaURL); | ||
113 | updatePacket.ParcelData.MusicURL = Helpers.StringToField(landData.musicURL); | ||
114 | updatePacket.ParcelData.Name = Helpers.StringToField(landData.landName); | ||
115 | updatePacket.ParcelData.OtherCleanTime = 0; //unemplemented | ||
116 | updatePacket.ParcelData.OtherCount = 0; //unemplemented | ||
117 | updatePacket.ParcelData.OtherPrims = landData.otherPrims; | ||
118 | updatePacket.ParcelData.OwnerID = landData.ownerID; | ||
119 | updatePacket.ParcelData.OwnerPrims = landData.ownerPrims; | ||
120 | updatePacket.ParcelData.ParcelFlags = landData.landFlags; | ||
121 | updatePacket.ParcelData.ParcelPrimBonus = m_world.RegionInfo.estateSettings.objectBonusFactor; | ||
122 | updatePacket.ParcelData.PassHours = landData.passHours; | ||
123 | updatePacket.ParcelData.PassPrice = landData.passPrice; | ||
124 | updatePacket.ParcelData.PublicCount = 0; //unemplemented | ||
125 | updatePacket.ParcelData.RegionDenyAnonymous = (((uint)m_world.RegionInfo.estateSettings.regionFlags & (uint)Simulator.RegionFlags.DenyAnonymous) > 0); | ||
126 | updatePacket.ParcelData.RegionDenyIdentified = (((uint)m_world.RegionInfo.estateSettings.regionFlags & (uint)Simulator.RegionFlags.DenyIdentified) > 0); | ||
127 | updatePacket.ParcelData.RegionDenyTransacted = (((uint)m_world.RegionInfo.estateSettings.regionFlags & (uint)Simulator.RegionFlags.DenyTransacted) > 0); | ||
128 | updatePacket.ParcelData.RegionPushOverride = (((uint)m_world.RegionInfo.estateSettings.regionFlags & (uint)Simulator.RegionFlags.RestrictPushObject) > 0); | ||
129 | updatePacket.ParcelData.RentPrice = 0; | ||
130 | updatePacket.ParcelData.RequestResult = request_result; | ||
131 | updatePacket.ParcelData.SalePrice = landData.salePrice; | ||
132 | updatePacket.ParcelData.SelectedPrims = landData.selectedPrims; | ||
133 | updatePacket.ParcelData.SelfCount = 0;//unemplemented | ||
134 | updatePacket.ParcelData.SequenceID = sequence_id; | ||
135 | if (landData.simwideArea > 0) | ||
136 | { | ||
137 | updatePacket.ParcelData.SimWideMaxPrims = Convert.ToInt32(Math.Round((Convert.ToDecimal(landData.simwideArea) / Convert.ToDecimal(65536)) * 15000 * Convert.ToDecimal(m_world.RegionInfo.estateSettings.objectBonusFactor))); | ||
138 | } | ||
139 | else | ||
140 | { | ||
141 | updatePacket.ParcelData.SimWideMaxPrims = 0; | ||
142 | } | ||
143 | updatePacket.ParcelData.SimWideTotalPrims = landData.simwidePrims; | ||
144 | updatePacket.ParcelData.SnapSelection = snap_selection; | ||
145 | updatePacket.ParcelData.SnapshotID = landData.snapshotID; | ||
146 | updatePacket.ParcelData.Status = (byte)landData.landStatus; | ||
147 | updatePacket.ParcelData.TotalPrims = landData.ownerPrims + landData.groupPrims + landData.otherPrims + landData.selectedPrims; | ||
148 | updatePacket.ParcelData.UserLocation = landData.userLocation; | ||
149 | updatePacket.ParcelData.UserLookAt = landData.userLookAt; | ||
150 | remote_client.OutPacket((Packet)updatePacket); | ||
151 | } | ||
152 | |||
153 | public void updateLandProperties(ParcelPropertiesUpdatePacket packet, IClientAPI remote_client) | ||
154 | { | ||
155 | if (remote_client.AgentId == landData.ownerID) | ||
156 | { | ||
157 | //Needs later group support | ||
158 | landData.authBuyerID = packet.ParcelData.AuthBuyerID; | ||
159 | landData.category = (libsecondlife.Parcel.ParcelCategory)packet.ParcelData.Category; | ||
160 | landData.landDesc = Helpers.FieldToUTF8String(packet.ParcelData.Desc); | ||
161 | landData.groupID = packet.ParcelData.GroupID; | ||
162 | landData.landingType = packet.ParcelData.LandingType; | ||
163 | landData.mediaAutoScale = packet.ParcelData.MediaAutoScale; | ||
164 | landData.mediaID = packet.ParcelData.MediaID; | ||
165 | landData.mediaURL = Helpers.FieldToUTF8String(packet.ParcelData.MediaURL); | ||
166 | landData.musicURL = Helpers.FieldToUTF8String(packet.ParcelData.MusicURL); | ||
167 | landData.landName = Helpers.FieldToUTF8String(packet.ParcelData.Name); | ||
168 | landData.landFlags = packet.ParcelData.ParcelFlags; | ||
169 | landData.passHours = packet.ParcelData.PassHours; | ||
170 | landData.passPrice = packet.ParcelData.PassPrice; | ||
171 | landData.salePrice = packet.ParcelData.SalePrice; | ||
172 | landData.snapshotID = packet.ParcelData.SnapshotID; | ||
173 | landData.userLocation = packet.ParcelData.UserLocation; | ||
174 | landData.userLookAt = packet.ParcelData.UserLookAt; | ||
175 | sendLandUpdateToAvatarsOverMe(); | ||
176 | |||
177 | |||
178 | } | ||
179 | } | ||
180 | |||
181 | public void sendLandUpdateToAvatarsOverMe() | ||
182 | { | ||
183 | List<ScenePresence> avatars = m_world.RequestAvatarList(); | ||
184 | for (int i = 0; i < avatars.Count; i++) | ||
185 | { | ||
186 | Land over = m_world.LandManager.getLandObject((int)Math.Round(avatars[i].Pos.X), (int)Math.Round(avatars[i].Pos.Y)); | ||
187 | if (over.landData.localID == this.landData.localID) | ||
188 | { | ||
189 | sendLandProperties(0, false, 0, avatars[i].ControllingClient); | ||
190 | } | ||
191 | } | ||
192 | } | ||
193 | #endregion | ||
194 | |||
195 | |||
196 | #region Update Functions | ||
197 | /// <summary> | ||
198 | /// Updates the AABBMin and AABBMax values after area/shape modification of the land object | ||
199 | /// </summary> | ||
200 | private void updateAABBAndAreaValues() | ||
201 | { | ||
202 | int min_x = 64; | ||
203 | int min_y = 64; | ||
204 | int max_x = 0; | ||
205 | int max_y = 0; | ||
206 | int tempArea = 0; | ||
207 | int x, y; | ||
208 | for (x = 0; x < 64; x++) | ||
209 | { | ||
210 | for (y = 0; y < 64; y++) | ||
211 | { | ||
212 | if (landBitmap[x, y] == true) | ||
213 | { | ||
214 | if (min_x > x) min_x = x; | ||
215 | if (min_y > y) min_y = y; | ||
216 | if (max_x < x) max_x = x; | ||
217 | if (max_y < y) max_y = y; | ||
218 | tempArea += 16; //16sqm peice of land | ||
219 | } | ||
220 | } | ||
221 | } | ||
222 | landData.AABBMin = new LLVector3((float)(min_x * 4), (float)(min_y * 4), (float)m_world.Terrain.get((min_x * 4), (min_y * 4))); | ||
223 | landData.AABBMax = new LLVector3((float)(max_x * 4), (float)(max_y * 4), (float)m_world.Terrain.get((max_x * 4), (max_y * 4))); | ||
224 | landData.area = tempArea; | ||
225 | } | ||
226 | |||
227 | public void updateLandBitmapByteArray() | ||
228 | { | ||
229 | landData.landBitmapByteArray = convertLandBitmapToBytes(); | ||
230 | } | ||
231 | |||
232 | /// <summary> | ||
233 | /// Update all settings in land such as area, bitmap byte array, etc | ||
234 | /// </summary> | ||
235 | public void forceUpdateLandInfo() | ||
236 | { | ||
237 | this.updateAABBAndAreaValues(); | ||
238 | this.updateLandBitmapByteArray(); | ||
239 | } | ||
240 | |||
241 | public void setLandBitmapFromByteArray() | ||
242 | { | ||
243 | landBitmap = convertBytesToLandBitmap(); | ||
244 | } | ||
245 | #endregion | ||
246 | |||
247 | |||
248 | #region Land Bitmap Functions | ||
249 | /// <summary> | ||
250 | /// Sets the land's bitmap manually | ||
251 | /// </summary> | ||
252 | /// <param name="bitmap">64x64 block representing where this land is on a map</param> | ||
253 | public void setLandBitmap(bool[,] bitmap) | ||
254 | { | ||
255 | if (bitmap.GetLength(0) != 64 || bitmap.GetLength(1) != 64 || bitmap.Rank != 2) | ||
256 | { | ||
257 | //Throw an exception - The bitmap is not 64x64 | ||
258 | throw new Exception("Error: Invalid Parcel Bitmap"); | ||
259 | } | ||
260 | else | ||
261 | { | ||
262 | //Valid: Lets set it | ||
263 | landBitmap = bitmap; | ||
264 | forceUpdateLandInfo(); | ||
265 | |||
266 | } | ||
267 | } | ||
268 | /// <summary> | ||
269 | /// Gets the land's bitmap manually | ||
270 | /// </summary> | ||
271 | /// <returns></returns> | ||
272 | public bool[,] getLandBitmap() | ||
273 | { | ||
274 | return landBitmap; | ||
275 | } | ||
276 | /// <summary> | ||
277 | /// Converts the land bitmap to a packet friendly byte array | ||
278 | /// </summary> | ||
279 | /// <returns></returns> | ||
280 | private byte[] convertLandBitmapToBytes() | ||
281 | { | ||
282 | byte[] tempConvertArr = new byte[512]; | ||
283 | byte tempByte = 0; | ||
284 | int x, y, i, byteNum = 0; | ||
285 | i = 0; | ||
286 | for (y = 0; y < 64; y++) | ||
287 | { | ||
288 | for (x = 0; x < 64; x++) | ||
289 | { | ||
290 | tempByte = Convert.ToByte(tempByte | Convert.ToByte(landBitmap[x, y]) << (i++ % 8)); | ||
291 | if (i % 8 == 0) | ||
292 | { | ||
293 | tempConvertArr[byteNum] = tempByte; | ||
294 | tempByte = (byte)0; | ||
295 | i = 0; | ||
296 | byteNum++; | ||
297 | } | ||
298 | } | ||
299 | } | ||
300 | return tempConvertArr; | ||
301 | } | ||
302 | |||
303 | private bool[,] convertBytesToLandBitmap() | ||
304 | { | ||
305 | bool[,] tempConvertMap = new bool[64, 64]; | ||
306 | tempConvertMap.Initialize(); | ||
307 | byte tempByte = 0; | ||
308 | int x = 0, y = 0, i = 0, bitNum = 0; | ||
309 | for (i = 0; i < 512; i++) | ||
310 | { | ||
311 | tempByte = landData.landBitmapByteArray[i]; | ||
312 | for (bitNum = 0; bitNum < 8; bitNum++) | ||
313 | { | ||
314 | bool bit = Convert.ToBoolean(Convert.ToByte(tempByte >> bitNum) & (byte)1); | ||
315 | tempConvertMap[x, y] = bit; | ||
316 | x++; | ||
317 | if (x > 63) | ||
318 | { | ||
319 | x = 0; | ||
320 | y++; | ||
321 | } | ||
322 | |||
323 | } | ||
324 | |||
325 | } | ||
326 | return tempConvertMap; | ||
327 | } | ||
328 | /// <summary> | ||
329 | /// Full sim land object creation | ||
330 | /// </summary> | ||
331 | /// <returns></returns> | ||
332 | public static bool[,] basicFullRegionLandBitmap() | ||
333 | { | ||
334 | return getSquareLandBitmap(0, 0, 256, 256); | ||
335 | } | ||
336 | |||
337 | /// <summary> | ||
338 | /// Used to modify the bitmap between the x and y points. Points use 64 scale | ||
339 | /// </summary> | ||
340 | /// <param name="start_x"></param> | ||
341 | /// <param name="start_y"></param> | ||
342 | /// <param name="end_x"></param> | ||
343 | /// <param name="end_y"></param> | ||
344 | /// <returns></returns> | ||
345 | public static bool[,] getSquareLandBitmap(int start_x, int start_y, int end_x, int end_y) | ||
346 | { | ||
347 | |||
348 | bool[,] tempBitmap = new bool[64, 64]; | ||
349 | tempBitmap.Initialize(); | ||
350 | |||
351 | tempBitmap = modifyLandBitmapSquare(tempBitmap, start_x, start_y, end_x, end_y, true); | ||
352 | return tempBitmap; | ||
353 | } | ||
354 | |||
355 | /// <summary> | ||
356 | /// Change a land bitmap at within a square and set those points to a specific value | ||
357 | /// </summary> | ||
358 | /// <param name="land_bitmap"></param> | ||
359 | /// <param name="start_x"></param> | ||
360 | /// <param name="start_y"></param> | ||
361 | /// <param name="end_x"></param> | ||
362 | /// <param name="end_y"></param> | ||
363 | /// <param name="set_value"></param> | ||
364 | /// <returns></returns> | ||
365 | public static bool[,] modifyLandBitmapSquare(bool[,] land_bitmap, int start_x, int start_y, int end_x, int end_y, bool set_value) | ||
366 | { | ||
367 | if (land_bitmap.GetLength(0) != 64 || land_bitmap.GetLength(1) != 64 || land_bitmap.Rank != 2) | ||
368 | { | ||
369 | //Throw an exception - The bitmap is not 64x64 | ||
370 | throw new Exception("Error: Invalid Parcel Bitmap in modifyLandBitmapSquare()"); | ||
371 | } | ||
372 | |||
373 | int x, y; | ||
374 | for (y = 0; y < 64; y++) | ||
375 | { | ||
376 | for (x = 0; x < 64; x++) | ||
377 | { | ||
378 | if (x >= start_x / 4 && x < end_x / 4 | ||
379 | && y >= start_y / 4 && y < end_y / 4) | ||
380 | { | ||
381 | land_bitmap[x, y] = set_value; | ||
382 | } | ||
383 | } | ||
384 | } | ||
385 | return land_bitmap; | ||
386 | } | ||
387 | /// <summary> | ||
388 | /// Join the true values of 2 bitmaps together | ||
389 | /// </summary> | ||
390 | /// <param name="bitmap_base"></param> | ||
391 | /// <param name="bitmap_add"></param> | ||
392 | /// <returns></returns> | ||
393 | public static bool[,] mergeLandBitmaps(bool[,] bitmap_base, bool[,] bitmap_add) | ||
394 | { | ||
395 | if (bitmap_base.GetLength(0) != 64 || bitmap_base.GetLength(1) != 64 || bitmap_base.Rank != 2) | ||
396 | { | ||
397 | //Throw an exception - The bitmap is not 64x64 | ||
398 | throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_base in mergeLandBitmaps"); | ||
399 | } | ||
400 | if (bitmap_add.GetLength(0) != 64 || bitmap_add.GetLength(1) != 64 || bitmap_add.Rank != 2) | ||
401 | { | ||
402 | //Throw an exception - The bitmap is not 64x64 | ||
403 | throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_add in mergeLandBitmaps"); | ||
404 | |||
405 | } | ||
406 | |||
407 | int x, y; | ||
408 | for (y = 0; y < 64; y++) | ||
409 | { | ||
410 | for (x = 0; x < 64; x++) | ||
411 | { | ||
412 | if (bitmap_add[x, y]) | ||
413 | { | ||
414 | bitmap_base[x, y] = true; | ||
415 | } | ||
416 | } | ||
417 | } | ||
418 | return bitmap_base; | ||
419 | } | ||
420 | #endregion | ||
421 | |||
422 | #region Object Select and Object Owner Listing | ||
423 | public void sendForceObjectSelect(int local_id, int request_type, IClientAPI remote_client) | ||
424 | { | ||
425 | List<uint> resultLocalIDs = new List<uint>(); | ||
426 | foreach (SceneObject obj in primsOverMe) | ||
427 | { | ||
428 | if (obj.rootLocalID > 0) | ||
429 | { | ||
430 | if (request_type == LandManager.LAND_SELECT_OBJECTS_OWNER && obj.rootPrimitive.OwnerID == this.landData.ownerID) | ||
431 | { | ||
432 | resultLocalIDs.Add(obj.rootLocalID); | ||
433 | } | ||
434 | else if (request_type == LandManager.LAND_SELECT_OBJECTS_GROUP && false) //TODO: change false to group support! | ||
435 | { | ||
436 | |||
437 | } | ||
438 | else if (request_type == LandManager.LAND_SELECT_OBJECTS_OTHER && obj.rootPrimitive.OwnerID != remote_client.AgentId) | ||
439 | { | ||
440 | resultLocalIDs.Add(obj.rootLocalID); | ||
441 | } | ||
442 | } | ||
443 | } | ||
444 | |||
445 | |||
446 | bool firstCall = true; | ||
447 | int MAX_OBJECTS_PER_PACKET = 251; | ||
448 | ForceObjectSelectPacket pack = new ForceObjectSelectPacket(); | ||
449 | ForceObjectSelectPacket.DataBlock[] data; | ||
450 | while (resultLocalIDs.Count > 0) | ||
451 | { | ||
452 | if (firstCall) | ||
453 | { | ||
454 | pack._Header.ResetList = true; | ||
455 | firstCall = false; | ||
456 | } | ||
457 | else | ||
458 | { | ||
459 | pack._Header.ResetList = false; | ||
460 | } | ||
461 | |||
462 | if (resultLocalIDs.Count > MAX_OBJECTS_PER_PACKET) | ||
463 | { | ||
464 | data = new ForceObjectSelectPacket.DataBlock[MAX_OBJECTS_PER_PACKET]; | ||
465 | } | ||
466 | else | ||
467 | { | ||
468 | data = new ForceObjectSelectPacket.DataBlock[resultLocalIDs.Count]; | ||
469 | } | ||
470 | |||
471 | int i; | ||
472 | for (i = 0; i < MAX_OBJECTS_PER_PACKET && resultLocalIDs.Count > 0; i++) | ||
473 | { | ||
474 | data[i] = new ForceObjectSelectPacket.DataBlock(); | ||
475 | data[i].LocalID = Convert.ToUInt32(resultLocalIDs[0]); | ||
476 | resultLocalIDs.RemoveAt(0); | ||
477 | } | ||
478 | pack.Data = data; | ||
479 | remote_client.OutPacket((Packet)pack); | ||
480 | } | ||
481 | |||
482 | } | ||
483 | public void sendLandObjectOwners(IClientAPI remote_client) | ||
484 | { | ||
485 | Dictionary<LLUUID, int> ownersAndCount = new Dictionary<LLUUID, int>(); | ||
486 | foreach (SceneObject obj in primsOverMe) | ||
487 | { | ||
488 | if (!ownersAndCount.ContainsKey(obj.rootPrimitive.OwnerID)) | ||
489 | { | ||
490 | ownersAndCount.Add(obj.rootPrimitive.OwnerID, 0); | ||
491 | } | ||
492 | ownersAndCount[obj.rootPrimitive.OwnerID] += obj.primCount; | ||
493 | } | ||
494 | if (ownersAndCount.Count > 0) | ||
495 | { | ||
496 | |||
497 | ParcelObjectOwnersReplyPacket.DataBlock[] dataBlock = new ParcelObjectOwnersReplyPacket.DataBlock[32]; | ||
498 | |||
499 | if (ownersAndCount.Count < 32) | ||
500 | { | ||
501 | dataBlock = new ParcelObjectOwnersReplyPacket.DataBlock[ownersAndCount.Count]; | ||
502 | } | ||
503 | |||
504 | |||
505 | int num = 0; | ||
506 | foreach (LLUUID owner in ownersAndCount.Keys) | ||
507 | { | ||
508 | dataBlock[num] = new ParcelObjectOwnersReplyPacket.DataBlock(); | ||
509 | dataBlock[num].Count = ownersAndCount[owner]; | ||
510 | dataBlock[num].IsGroupOwned = false; //TODO: fix me when group support is added | ||
511 | dataBlock[num].OnlineStatus = true; //TODO: fix me later | ||
512 | dataBlock[num].OwnerID = owner; | ||
513 | |||
514 | num++; | ||
515 | } | ||
516 | |||
517 | ParcelObjectOwnersReplyPacket pack = new ParcelObjectOwnersReplyPacket(); | ||
518 | pack.Data = dataBlock; | ||
519 | remote_client.OutPacket(pack); | ||
520 | } | ||
521 | } | ||
522 | #endregion | ||
523 | |||
524 | #region Object Returning | ||
525 | public void returnObject(SceneObject obj) | ||
526 | { | ||
527 | } | ||
528 | public void returnLandObjects(int type, LLUUID owner) | ||
529 | { | ||
530 | |||
531 | } | ||
532 | #endregion | ||
533 | |||
534 | #region Object Adding/Removing from Parcel | ||
535 | public void resetLandPrimCounts() | ||
536 | { | ||
537 | landData.groupPrims = 0; | ||
538 | landData.ownerPrims = 0; | ||
539 | landData.otherPrims = 0; | ||
540 | landData.selectedPrims = 0; | ||
541 | primsOverMe.Clear(); | ||
542 | } | ||
543 | |||
544 | public void addPrimToCount(SceneObject obj) | ||
545 | { | ||
546 | LLUUID prim_owner = obj.rootPrimitive.OwnerID; | ||
547 | int prim_count = obj.primCount; | ||
548 | |||
549 | if (obj.isSelected) | ||
550 | { | ||
551 | landData.selectedPrims += prim_count; | ||
552 | } | ||
553 | else | ||
554 | { | ||
555 | if (prim_owner == landData.ownerID) | ||
556 | { | ||
557 | landData.ownerPrims += prim_count; | ||
558 | } | ||
559 | else | ||
560 | { | ||
561 | landData.otherPrims += prim_count; | ||
562 | } | ||
563 | } | ||
564 | |||
565 | primsOverMe.Add(obj); | ||
566 | |||
567 | } | ||
568 | |||
569 | public void removePrimFromCount(SceneObject obj) | ||
570 | { | ||
571 | if (primsOverMe.Contains(obj)) | ||
572 | { | ||
573 | LLUUID prim_owner = obj.rootPrimitive.OwnerID; | ||
574 | int prim_count = obj.primCount; | ||
575 | |||
576 | if (prim_owner == landData.ownerID) | ||
577 | { | ||
578 | landData.ownerPrims -= prim_count; | ||
579 | } | ||
580 | else if (prim_owner == landData.groupID) | ||
581 | { | ||
582 | landData.groupPrims -= prim_count; | ||
583 | } | ||
584 | else | ||
585 | { | ||
586 | landData.otherPrims -= prim_count; | ||
587 | } | ||
588 | |||
589 | primsOverMe.Remove(obj); | ||
590 | } | ||
591 | } | ||
592 | #endregion | ||
593 | |||
594 | #endregion | ||
595 | |||
596 | |||
597 | } | ||
598 | #endregion | ||
599 | } | ||