diff options
Switched in NameSpaceChanges
Diffstat (limited to 'OpenSim/OpenSim.Region/ParcelManager.cs')
-rw-r--r-- | OpenSim/OpenSim.Region/ParcelManager.cs | 892 |
1 files changed, 0 insertions, 892 deletions
diff --git a/OpenSim/OpenSim.Region/ParcelManager.cs b/OpenSim/OpenSim.Region/ParcelManager.cs deleted file mode 100644 index d15d77d..0000000 --- a/OpenSim/OpenSim.Region/ParcelManager.cs +++ /dev/null | |||
@@ -1,892 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://www.openmetaverse.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSim Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | * | ||
27 | */ | ||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Text; | ||
31 | using libsecondlife; | ||
32 | using libsecondlife.Packets; | ||
33 | using OpenSim.Framework.Interfaces; | ||
34 | using OpenSim.Framework.Types; | ||
35 | using OpenSim.Region.Scenes; | ||
36 | using Avatar = OpenSim.Region.Scenes.ScenePresence; | ||
37 | |||
38 | namespace OpenSim.Region | ||
39 | { | ||
40 | |||
41 | |||
42 | #region ParcelManager Class | ||
43 | /// <summary> | ||
44 | /// Handles Parcel objects and operations requiring information from other Parcel objects (divide, join, etc) | ||
45 | /// </summary> | ||
46 | public class ParcelManager : OpenSim.Framework.Interfaces.ILocalStorageParcelReceiver | ||
47 | { | ||
48 | |||
49 | #region Constants | ||
50 | //Parcel types set with flags in ParcelOverlay. | ||
51 | //Only one of these can be used. | ||
52 | public const byte PARCEL_TYPE_PUBLIC = (byte)0; //Equals 00000000 | ||
53 | public const byte PARCEL_TYPE_OWNED_BY_OTHER = (byte)1; //Equals 00000001 | ||
54 | public const byte PARCEL_TYPE_OWNED_BY_GROUP = (byte)2; //Equals 00000010 | ||
55 | public const byte PARCEL_TYPE_OWNED_BY_REQUESTER = (byte)3; //Equals 00000011 | ||
56 | public const byte PARCEL_TYPE_IS_FOR_SALE = (byte)4; //Equals 00000100 | ||
57 | public const byte PARCEL_TYPE_IS_BEING_AUCTIONED = (byte)5; //Equals 00000101 | ||
58 | |||
59 | |||
60 | //Flags that when set, a border on the given side will be placed | ||
61 | //NOTE: North and East is assumable by the west and south sides (if parcel to east has a west border, then I have an east border; etc) | ||
62 | //This took forever to figure out -- jeesh. /blame LL for even having to send these | ||
63 | public const byte PARCEL_FLAG_PROPERTY_BORDER_WEST = (byte)64; //Equals 01000000 | ||
64 | public const byte PARCEL_FLAG_PROPERTY_BORDER_SOUTH = (byte)128; //Equals 10000000 | ||
65 | |||
66 | //RequestResults (I think these are right, they seem to work): | ||
67 | public const int PARCEL_RESULT_ONE_PARCEL = 0; // The request they made contained only one parcel | ||
68 | public const int PARCEL_RESULT_MULTIPLE_PARCELS = 1; // The request they made contained more than one parcel | ||
69 | |||
70 | //These are other constants. Yay! | ||
71 | public const int START_PARCEL_LOCAL_ID = 1; | ||
72 | #endregion | ||
73 | |||
74 | #region Member Variables | ||
75 | public Dictionary<int, Parcel> parcelList = new Dictionary<int, Parcel>(); | ||
76 | private int lastParcelLocalID = START_PARCEL_LOCAL_ID - 1; | ||
77 | private int[,] parcelIDList = new int[64, 64]; | ||
78 | |||
79 | private Scene m_world; | ||
80 | private RegionInfo m_regInfo; | ||
81 | |||
82 | #endregion | ||
83 | |||
84 | #region Constructors | ||
85 | public ParcelManager(Scene world, RegionInfo reginfo) | ||
86 | { | ||
87 | |||
88 | m_world = world; | ||
89 | m_regInfo = reginfo; | ||
90 | parcelIDList.Initialize(); | ||
91 | |||
92 | } | ||
93 | #endregion | ||
94 | |||
95 | #region Member Functions | ||
96 | |||
97 | #region Parcel From Storage Functions | ||
98 | public void ParcelFromStorage(ParcelData data) | ||
99 | { | ||
100 | Parcel new_parcel = new Parcel(data.ownerID, data.isGroupOwned, m_world); | ||
101 | new_parcel.parcelData = data.Copy(); | ||
102 | new_parcel.setParcelBitmapFromByteArray(); | ||
103 | addParcel(new_parcel); | ||
104 | |||
105 | } | ||
106 | |||
107 | public void NoParcelDataFromStorage() | ||
108 | { | ||
109 | resetSimParcels(); | ||
110 | } | ||
111 | #endregion | ||
112 | |||
113 | #region Parcel Add/Remove/Get/Create | ||
114 | /// <summary> | ||
115 | /// Creates a basic Parcel object without an owner (a zeroed key) | ||
116 | /// </summary> | ||
117 | /// <returns></returns> | ||
118 | public Parcel createBaseParcel() | ||
119 | { | ||
120 | return new Parcel(new LLUUID(), false, m_world); | ||
121 | } | ||
122 | |||
123 | /// <summary> | ||
124 | /// Adds a parcel to the stored list and adds them to the parcelIDList to what they own | ||
125 | /// </summary> | ||
126 | /// <param name="new_parcel">The parcel being added</param> | ||
127 | public void addParcel(Parcel new_parcel) | ||
128 | { | ||
129 | lastParcelLocalID++; | ||
130 | new_parcel.parcelData.localID = lastParcelLocalID; | ||
131 | parcelList.Add(lastParcelLocalID, new_parcel.Copy()); | ||
132 | |||
133 | |||
134 | bool[,] parcelBitmap = new_parcel.getParcelBitmap(); | ||
135 | int x, y; | ||
136 | for (x = 0; x < 64; x++) | ||
137 | { | ||
138 | for (y = 0; y < 64; y++) | ||
139 | { | ||
140 | if (parcelBitmap[x, y]) | ||
141 | { | ||
142 | parcelIDList[x, y] = lastParcelLocalID; | ||
143 | } | ||
144 | } | ||
145 | } | ||
146 | parcelList[lastParcelLocalID].forceUpdateParcelInfo(); | ||
147 | |||
148 | |||
149 | } | ||
150 | /// <summary> | ||
151 | /// Removes a parcel from the list. Will not remove if local_id is still owning an area in parcelIDList | ||
152 | /// </summary> | ||
153 | /// <param name="local_id">Parcel.localID of the parcel to remove.</param> | ||
154 | public void removeParcel(int local_id) | ||
155 | { | ||
156 | int x, y; | ||
157 | for (x = 0; x < 64; x++) | ||
158 | { | ||
159 | for (y = 0; y < 64; y++) | ||
160 | { | ||
161 | if (parcelIDList[x, y] == local_id) | ||
162 | { | ||
163 | throw new Exception("Could not remove parcel. Still being used at " + x + ", " + y); | ||
164 | } | ||
165 | } | ||
166 | } | ||
167 | m_world.localStorage.RemoveParcel(parcelList[local_id].parcelData); | ||
168 | parcelList.Remove(local_id); | ||
169 | } | ||
170 | |||
171 | private void performFinalParcelJoin(Parcel master, Parcel slave) | ||
172 | { | ||
173 | int x, y; | ||
174 | bool[,] parcelBitmapSlave = slave.getParcelBitmap(); | ||
175 | for (x = 0; x < 64; x++) | ||
176 | { | ||
177 | for (y = 0; y < 64; y++) | ||
178 | { | ||
179 | if (parcelBitmapSlave[x, y]) | ||
180 | { | ||
181 | parcelIDList[x, y] = master.parcelData.localID; | ||
182 | } | ||
183 | } | ||
184 | } | ||
185 | removeParcel(slave.parcelData.localID); | ||
186 | } | ||
187 | /// <summary> | ||
188 | /// Get the parcel at the specified point | ||
189 | /// </summary> | ||
190 | /// <param name="x">Value between 0 - 256 on the x axis of the point</param> | ||
191 | /// <param name="y">Value between 0 - 256 on the y axis of the point</param> | ||
192 | /// <returns>Parcel at the point supplied</returns> | ||
193 | public Parcel getParcel(int x, int y) | ||
194 | { | ||
195 | if (x > 256 || y > 256 || x < 0 || y < 0) | ||
196 | { | ||
197 | throw new Exception("Error: Parcel not found at point " + x + ", " + y); | ||
198 | } | ||
199 | else | ||
200 | { | ||
201 | return parcelList[parcelIDList[x / 4, y / 4]]; | ||
202 | } | ||
203 | |||
204 | } | ||
205 | #endregion | ||
206 | |||
207 | #region Parcel Modification | ||
208 | /// <summary> | ||
209 | /// Subdivides a parcel | ||
210 | /// </summary> | ||
211 | /// <param name="start_x">West Point</param> | ||
212 | /// <param name="start_y">South Point</param> | ||
213 | /// <param name="end_x">East Point</param> | ||
214 | /// <param name="end_y">North Point</param> | ||
215 | /// <param name="attempting_user_id">LLUUID of user who is trying to subdivide</param> | ||
216 | /// <returns>Returns true if successful</returns> | ||
217 | private bool subdivide(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id) | ||
218 | { | ||
219 | //First, lets loop through the points and make sure they are all in the same parcel | ||
220 | //Get the parcel at start | ||
221 | Parcel startParcel = getParcel(start_x, start_y); | ||
222 | if (startParcel == null) return false; //No such parcel at the beginning | ||
223 | |||
224 | //Loop through the points | ||
225 | try | ||
226 | { | ||
227 | int totalX = end_x - start_x; | ||
228 | int totalY = end_y - start_y; | ||
229 | int x, y; | ||
230 | for (y = 0; y < totalY; y++) | ||
231 | { | ||
232 | for (x = 0; x < totalX; x++) | ||
233 | { | ||
234 | Parcel tempParcel = getParcel(start_x + x, start_y + y); | ||
235 | if (tempParcel == null) return false; //No such parcel at that point | ||
236 | if (tempParcel != startParcel) return false; //Subdividing over 2 parcels; no-no | ||
237 | } | ||
238 | } | ||
239 | } | ||
240 | catch (Exception) | ||
241 | { | ||
242 | return false; //Exception. For now, lets skip subdivision | ||
243 | } | ||
244 | |||
245 | //If we are still here, then they are subdividing within one parcel | ||
246 | //Check owner | ||
247 | if (startParcel.parcelData.ownerID != attempting_user_id) | ||
248 | { | ||
249 | return false; //They cant do this! | ||
250 | } | ||
251 | |||
252 | //Lets create a new parcel with bitmap activated at that point (keeping the old parcels info) | ||
253 | Parcel newParcel = startParcel.Copy(); | ||
254 | newParcel.parcelData.parcelName = "Subdivision of " + newParcel.parcelData.parcelName; | ||
255 | newParcel.parcelData.globalID = LLUUID.Random(); | ||
256 | |||
257 | newParcel.setParcelBitmap(Parcel.getSquareParcelBitmap(start_x, start_y, end_x, end_y)); | ||
258 | |||
259 | //Now, lets set the subdivision area of the original to false | ||
260 | int startParcelIndex = startParcel.parcelData.localID; | ||
261 | parcelList[startParcelIndex].setParcelBitmap(Parcel.modifyParcelBitmapSquare(startParcel.getParcelBitmap(), start_x, start_y, end_x, end_y, false)); | ||
262 | parcelList[startParcelIndex].forceUpdateParcelInfo(); | ||
263 | |||
264 | |||
265 | //Now add the new parcel | ||
266 | addParcel(newParcel); | ||
267 | |||
268 | |||
269 | |||
270 | |||
271 | |||
272 | return true; | ||
273 | } | ||
274 | /// <summary> | ||
275 | /// Join 2 parcels together | ||
276 | /// </summary> | ||
277 | /// <param name="start_x">x value in first parcel</param> | ||
278 | /// <param name="start_y">y value in first parcel</param> | ||
279 | /// <param name="end_x">x value in second parcel</param> | ||
280 | /// <param name="end_y">y value in second parcel</param> | ||
281 | /// <param name="attempting_user_id">LLUUID of the avatar trying to join the parcels</param> | ||
282 | /// <returns>Returns true if successful</returns> | ||
283 | private bool join(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id) | ||
284 | { | ||
285 | end_x -= 4; | ||
286 | end_y -= 4; | ||
287 | |||
288 | //NOTE: The following only connects the parcels in each corner and not all the parcels that are within the selection box! | ||
289 | //This should be fixed later -- somewhat "incomplete code" --Ming | ||
290 | Parcel startParcel, endParcel; | ||
291 | |||
292 | try | ||
293 | { | ||
294 | startParcel = getParcel(start_x, start_y); | ||
295 | endParcel = getParcel(end_x, end_y); | ||
296 | } | ||
297 | catch (Exception) | ||
298 | { | ||
299 | return false; //Error occured when trying to get the start and end parcels | ||
300 | } | ||
301 | if (startParcel == endParcel) | ||
302 | { | ||
303 | return false; //Subdivision of the same parcel is not allowed | ||
304 | } | ||
305 | |||
306 | //Check the parcel owners: | ||
307 | if (startParcel.parcelData.ownerID != endParcel.parcelData.ownerID) | ||
308 | { | ||
309 | return false; | ||
310 | } | ||
311 | if (startParcel.parcelData.ownerID != attempting_user_id) | ||
312 | { | ||
313 | //TODO: Group editing stuff. Avatar owner support for now | ||
314 | return false; | ||
315 | } | ||
316 | |||
317 | //Same owners! Lets join them | ||
318 | //Merge them to startParcel | ||
319 | parcelList[startParcel.parcelData.localID].setParcelBitmap(Parcel.mergeParcelBitmaps(startParcel.getParcelBitmap(), endParcel.getParcelBitmap())); | ||
320 | performFinalParcelJoin(startParcel, endParcel); | ||
321 | |||
322 | return true; | ||
323 | |||
324 | |||
325 | |||
326 | } | ||
327 | #endregion | ||
328 | |||
329 | #region Parcel Updating | ||
330 | /// <summary> | ||
331 | /// Where we send the ParcelOverlay packet to the client | ||
332 | /// </summary> | ||
333 | /// <param name="remote_client">The object representing the client</param> | ||
334 | public void sendParcelOverlay(IClientAPI remote_client) | ||
335 | { | ||
336 | const int PARCEL_BLOCKS_PER_PACKET = 1024; | ||
337 | int x, y = 0; | ||
338 | byte[] byteArray = new byte[PARCEL_BLOCKS_PER_PACKET]; | ||
339 | int byteArrayCount = 0; | ||
340 | int sequenceID = 0; | ||
341 | ParcelOverlayPacket packet; | ||
342 | |||
343 | for (y = 0; y < 64; y++) | ||
344 | { | ||
345 | for (x = 0; x < 64; x++) | ||
346 | { | ||
347 | byte tempByte = (byte)0; //This represents the byte for the current 4x4 | ||
348 | Parcel currentParcelBlock = getParcel(x * 4, y * 4); | ||
349 | |||
350 | if (currentParcelBlock.parcelData.ownerID == remote_client.AgentId) | ||
351 | { | ||
352 | //Owner Flag | ||
353 | tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_OWNED_BY_REQUESTER); | ||
354 | } | ||
355 | else if (currentParcelBlock.parcelData.salePrice > 0 && (currentParcelBlock.parcelData.authBuyerID == LLUUID.Zero || currentParcelBlock.parcelData.authBuyerID == remote_client.AgentId)) | ||
356 | { | ||
357 | //Sale Flag | ||
358 | tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_IS_FOR_SALE); | ||
359 | } | ||
360 | else if (currentParcelBlock.parcelData.ownerID == LLUUID.Zero) | ||
361 | { | ||
362 | //Public Flag | ||
363 | tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_PUBLIC); | ||
364 | } | ||
365 | else | ||
366 | { | ||
367 | //Other Flag | ||
368 | tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_OWNED_BY_OTHER); | ||
369 | } | ||
370 | |||
371 | |||
372 | //Now for border control | ||
373 | if (x == 0) | ||
374 | { | ||
375 | tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_WEST); | ||
376 | } | ||
377 | else if (getParcel((x - 1) * 4, y * 4) != currentParcelBlock) | ||
378 | { | ||
379 | tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_WEST); | ||
380 | } | ||
381 | |||
382 | if (y == 0) | ||
383 | { | ||
384 | tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_SOUTH); | ||
385 | } | ||
386 | else if (getParcel(x * 4, (y - 1) * 4) != currentParcelBlock) | ||
387 | { | ||
388 | tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_SOUTH); | ||
389 | } | ||
390 | |||
391 | byteArray[byteArrayCount] = tempByte; | ||
392 | byteArrayCount++; | ||
393 | if (byteArrayCount >= PARCEL_BLOCKS_PER_PACKET) | ||
394 | { | ||
395 | byteArrayCount = 0; | ||
396 | packet = new ParcelOverlayPacket(); | ||
397 | packet.ParcelData.Data = byteArray; | ||
398 | packet.ParcelData.SequenceID = sequenceID; | ||
399 | remote_client.OutPacket((Packet)packet); | ||
400 | sequenceID++; | ||
401 | byteArray = new byte[PARCEL_BLOCKS_PER_PACKET]; | ||
402 | } | ||
403 | } | ||
404 | } | ||
405 | |||
406 | packet = new ParcelOverlayPacket(); | ||
407 | packet.ParcelData.Data = byteArray; | ||
408 | packet.ParcelData.SequenceID = sequenceID; //Eh? | ||
409 | remote_client.OutPacket((Packet)packet); | ||
410 | } | ||
411 | |||
412 | public void handleParcelPropertiesRequest(int start_x, int start_y, int end_x, int end_y, int sequence_id, bool snap_selection, IClientAPI remote_client) | ||
413 | { | ||
414 | //Get the parcels within the bounds | ||
415 | List<Parcel> temp = new List<Parcel>(); | ||
416 | int x, y, i; | ||
417 | int inc_x = end_x - start_x; | ||
418 | int inc_y = end_y - start_y; | ||
419 | for (x = 0; x < inc_x; x++) | ||
420 | { | ||
421 | for (y = 0; y < inc_y; y++) | ||
422 | { | ||
423 | OpenSim.Region.Parcel currentParcel = getParcel(start_x + x, start_y + y); | ||
424 | if (!temp.Contains(currentParcel)) | ||
425 | { | ||
426 | currentParcel.forceUpdateParcelInfo(); | ||
427 | temp.Add(currentParcel); | ||
428 | } | ||
429 | } | ||
430 | } | ||
431 | |||
432 | int requestResult = ParcelManager.PARCEL_RESULT_ONE_PARCEL; | ||
433 | if (temp.Count > 1) | ||
434 | { | ||
435 | requestResult = ParcelManager.PARCEL_RESULT_MULTIPLE_PARCELS; | ||
436 | } | ||
437 | |||
438 | for (i = 0; i < temp.Count; i++) | ||
439 | { | ||
440 | temp[i].sendParcelProperties(sequence_id, snap_selection, requestResult, remote_client); | ||
441 | } | ||
442 | |||
443 | |||
444 | sendParcelOverlay(remote_client); | ||
445 | } | ||
446 | |||
447 | public void handleParcelPropertiesUpdateRequest(ParcelPropertiesUpdatePacket packet, IClientAPI remote_client) | ||
448 | { | ||
449 | if (parcelList.ContainsKey(packet.ParcelData.LocalID)) | ||
450 | { | ||
451 | parcelList[packet.ParcelData.LocalID].updateParcelProperties(packet, remote_client); | ||
452 | } | ||
453 | } | ||
454 | public void handleParcelDivideRequest(int west, int south, int east, int north, IClientAPI remote_client) | ||
455 | { | ||
456 | subdivide(west, south, east, north, remote_client.AgentId); | ||
457 | } | ||
458 | public void handleParcelJoinRequest(int west, int south, int east, int north, IClientAPI remote_client) | ||
459 | { | ||
460 | join(west, south, east, north, remote_client.AgentId); | ||
461 | |||
462 | } | ||
463 | #endregion | ||
464 | |||
465 | /// <summary> | ||
466 | /// Resets the sim to the default parcel (full sim parcel owned by the default user) | ||
467 | /// </summary> | ||
468 | public void resetSimParcels() | ||
469 | { | ||
470 | //Remove all the parcels in the sim and add a blank, full sim parcel set to public | ||
471 | parcelList.Clear(); | ||
472 | lastParcelLocalID = START_PARCEL_LOCAL_ID - 1; | ||
473 | parcelIDList.Initialize(); | ||
474 | |||
475 | Parcel fullSimParcel = new Parcel(LLUUID.Zero, false, m_world); | ||
476 | |||
477 | fullSimParcel.setParcelBitmap(Parcel.getSquareParcelBitmap(0, 0, 256, 256)); | ||
478 | fullSimParcel.parcelData.parcelName = "Your Sim Parcel"; | ||
479 | fullSimParcel.parcelData.parcelDesc = ""; | ||
480 | |||
481 | fullSimParcel.parcelData.ownerID = m_regInfo.MasterAvatarAssignedUUID; | ||
482 | fullSimParcel.parcelData.salePrice = 1; | ||
483 | fullSimParcel.parcelData.parcelFlags = libsecondlife.Parcel.ParcelFlags.ForSale; | ||
484 | fullSimParcel.parcelData.parcelStatus = libsecondlife.Parcel.ParcelStatus.Leased; | ||
485 | |||
486 | addParcel(fullSimParcel); | ||
487 | |||
488 | } | ||
489 | #endregion | ||
490 | } | ||
491 | #endregion | ||
492 | |||
493 | |||
494 | #region Parcel Class | ||
495 | /// <summary> | ||
496 | /// Keeps track of a specific parcel's information | ||
497 | /// </summary> | ||
498 | public class Parcel | ||
499 | { | ||
500 | #region Member Variables | ||
501 | public ParcelData parcelData = new ParcelData(); | ||
502 | public Scene m_world; | ||
503 | |||
504 | private bool[,] parcelBitmap = new bool[64, 64]; | ||
505 | |||
506 | #endregion | ||
507 | |||
508 | |||
509 | #region Constructors | ||
510 | public Parcel(LLUUID owner_id, bool is_group_owned, Scene world) | ||
511 | { | ||
512 | m_world = world; | ||
513 | parcelData.ownerID = owner_id; | ||
514 | parcelData.isGroupOwned = is_group_owned; | ||
515 | |||
516 | } | ||
517 | #endregion | ||
518 | |||
519 | |||
520 | #region Member Functions | ||
521 | |||
522 | #region General Functions | ||
523 | /// <summary> | ||
524 | /// Checks to see if this parcel contains a point | ||
525 | /// </summary> | ||
526 | /// <param name="x"></param> | ||
527 | /// <param name="y"></param> | ||
528 | /// <returns>Returns true if the parcel contains the specified point</returns> | ||
529 | public bool containsPoint(int x, int y) | ||
530 | { | ||
531 | if (x >= 0 && y >= 0 && x <= 256 && x <= 256) | ||
532 | { | ||
533 | return (parcelBitmap[x / 4, y / 4] == true); | ||
534 | } | ||
535 | else | ||
536 | { | ||
537 | return false; | ||
538 | } | ||
539 | } | ||
540 | |||
541 | public Parcel Copy() | ||
542 | { | ||
543 | Parcel newParcel = new Parcel(this.parcelData.ownerID, this.parcelData.isGroupOwned, m_world); | ||
544 | |||
545 | //Place all new variables here! | ||
546 | newParcel.parcelBitmap = (bool[,])(this.parcelBitmap.Clone()); | ||
547 | newParcel.parcelData = parcelData.Copy(); | ||
548 | |||
549 | return newParcel; | ||
550 | } | ||
551 | |||
552 | #endregion | ||
553 | |||
554 | |||
555 | #region Packet Request Handling | ||
556 | /// <summary> | ||
557 | /// Sends parcel properties as requested | ||
558 | /// </summary> | ||
559 | /// <param name="sequence_id">ID sent by client for them to keep track of</param> | ||
560 | /// <param name="snap_selection">Bool sent by client for them to use</param> | ||
561 | /// <param name="remote_client">Object representing the client</param> | ||
562 | public void sendParcelProperties(int sequence_id, bool snap_selection, int request_result, IClientAPI remote_client) | ||
563 | { | ||
564 | |||
565 | ParcelPropertiesPacket updatePacket = new ParcelPropertiesPacket(); | ||
566 | updatePacket.ParcelData.AABBMax = parcelData.AABBMax; | ||
567 | updatePacket.ParcelData.AABBMin = parcelData.AABBMin; | ||
568 | updatePacket.ParcelData.Area = parcelData.area; | ||
569 | updatePacket.ParcelData.AuctionID = parcelData.auctionID; | ||
570 | updatePacket.ParcelData.AuthBuyerID = parcelData.authBuyerID; //unemplemented | ||
571 | |||
572 | updatePacket.ParcelData.Bitmap = parcelData.parcelBitmapByteArray; | ||
573 | |||
574 | updatePacket.ParcelData.Desc = libsecondlife.Helpers.StringToField(parcelData.parcelDesc); | ||
575 | updatePacket.ParcelData.Category = (byte)parcelData.category; | ||
576 | updatePacket.ParcelData.ClaimDate = parcelData.claimDate; | ||
577 | updatePacket.ParcelData.ClaimPrice = parcelData.claimPrice; | ||
578 | updatePacket.ParcelData.GroupID = parcelData.groupID; | ||
579 | updatePacket.ParcelData.GroupPrims = parcelData.groupPrims; | ||
580 | updatePacket.ParcelData.IsGroupOwned = parcelData.isGroupOwned; | ||
581 | updatePacket.ParcelData.LandingType = (byte)parcelData.landingType; | ||
582 | updatePacket.ParcelData.LocalID = parcelData.localID; | ||
583 | updatePacket.ParcelData.MaxPrims = 1000; //unemplemented | ||
584 | updatePacket.ParcelData.MediaAutoScale = parcelData.mediaAutoScale; | ||
585 | updatePacket.ParcelData.MediaID = parcelData.mediaID; | ||
586 | updatePacket.ParcelData.MediaURL = Helpers.StringToField(parcelData.mediaURL); | ||
587 | updatePacket.ParcelData.MusicURL = Helpers.StringToField(parcelData.musicURL); | ||
588 | updatePacket.ParcelData.Name = Helpers.StringToField(parcelData.parcelName); | ||
589 | updatePacket.ParcelData.OtherCleanTime = 0; //unemplemented | ||
590 | updatePacket.ParcelData.OtherCount = 0; //unemplemented | ||
591 | updatePacket.ParcelData.OtherPrims = 0; //unemplented | ||
592 | updatePacket.ParcelData.OwnerID = parcelData.ownerID; | ||
593 | updatePacket.ParcelData.OwnerPrims = 0; //unemplemented | ||
594 | updatePacket.ParcelData.ParcelFlags = (uint)parcelData.parcelFlags; //unemplemented | ||
595 | updatePacket.ParcelData.ParcelPrimBonus = (float)1.0; //unemplemented | ||
596 | updatePacket.ParcelData.PassHours = parcelData.passHours; | ||
597 | updatePacket.ParcelData.PassPrice = parcelData.passPrice; | ||
598 | updatePacket.ParcelData.PublicCount = 0; //unemplemented | ||
599 | updatePacket.ParcelData.RegionDenyAnonymous = false; //unemplemented | ||
600 | updatePacket.ParcelData.RegionDenyIdentified = false; //unemplemented | ||
601 | updatePacket.ParcelData.RegionDenyTransacted = false; //unemplemented | ||
602 | updatePacket.ParcelData.RegionPushOverride = true; //unemplemented | ||
603 | updatePacket.ParcelData.RentPrice = 0; //?? | ||
604 | updatePacket.ParcelData.RequestResult = request_result; | ||
605 | updatePacket.ParcelData.SalePrice = parcelData.salePrice; //unemplemented | ||
606 | updatePacket.ParcelData.SelectedPrims = 0; //unemeplemented | ||
607 | updatePacket.ParcelData.SelfCount = 0;//unemplemented | ||
608 | updatePacket.ParcelData.SequenceID = sequence_id; | ||
609 | updatePacket.ParcelData.SimWideMaxPrims = 15000; //unemplemented | ||
610 | updatePacket.ParcelData.SimWideTotalPrims = 0; //unemplemented | ||
611 | updatePacket.ParcelData.SnapSelection = snap_selection; | ||
612 | updatePacket.ParcelData.SnapshotID = parcelData.snapshotID; | ||
613 | updatePacket.ParcelData.Status = (byte)parcelData.parcelStatus; | ||
614 | updatePacket.ParcelData.TotalPrims = 0; //unemplemented | ||
615 | updatePacket.ParcelData.UserLocation = parcelData.userLocation; | ||
616 | updatePacket.ParcelData.UserLookAt = parcelData.userLookAt; | ||
617 | remote_client.OutPacket((Packet)updatePacket); | ||
618 | } | ||
619 | |||
620 | public void updateParcelProperties(ParcelPropertiesUpdatePacket packet, IClientAPI remote_client) | ||
621 | { | ||
622 | if (remote_client.AgentId == parcelData.ownerID) | ||
623 | { | ||
624 | //Needs later group support | ||
625 | parcelData.authBuyerID = packet.ParcelData.AuthBuyerID; | ||
626 | parcelData.category = (libsecondlife.Parcel.ParcelCategory)packet.ParcelData.Category; | ||
627 | parcelData.parcelDesc = Helpers.FieldToUTF8String(packet.ParcelData.Desc); | ||
628 | parcelData.groupID = packet.ParcelData.GroupID; | ||
629 | parcelData.landingType = packet.ParcelData.LandingType; | ||
630 | parcelData.mediaAutoScale = packet.ParcelData.MediaAutoScale; | ||
631 | parcelData.mediaID = packet.ParcelData.MediaID; | ||
632 | parcelData.mediaURL = Helpers.FieldToUTF8String(packet.ParcelData.MediaURL); | ||
633 | parcelData.musicURL = Helpers.FieldToUTF8String(packet.ParcelData.MusicURL); | ||
634 | parcelData.parcelName = libsecondlife.Helpers.FieldToUTF8String(packet.ParcelData.Name); | ||
635 | parcelData.parcelFlags = (libsecondlife.Parcel.ParcelFlags)packet.ParcelData.ParcelFlags; | ||
636 | parcelData.passHours = packet.ParcelData.PassHours; | ||
637 | parcelData.passPrice = packet.ParcelData.PassPrice; | ||
638 | parcelData.salePrice = packet.ParcelData.SalePrice; | ||
639 | parcelData.snapshotID = packet.ParcelData.SnapshotID; | ||
640 | parcelData.userLocation = packet.ParcelData.UserLocation; | ||
641 | parcelData.userLookAt = packet.ParcelData.UserLookAt; | ||
642 | |||
643 | List<Avatar> avatars = m_world.RequestAvatarList(); | ||
644 | |||
645 | for (int i = 0; i < avatars.Count; i++) | ||
646 | { | ||
647 | Parcel over = m_world.parcelManager.getParcel((int)Math.Round(avatars[i].Pos.X), (int)Math.Round(avatars[i].Pos.Y)); | ||
648 | if (over == this) | ||
649 | { | ||
650 | sendParcelProperties(0, false, 0, avatars[i].ControllingClient); | ||
651 | } | ||
652 | } | ||
653 | |||
654 | } | ||
655 | } | ||
656 | #endregion | ||
657 | |||
658 | |||
659 | #region Update Functions | ||
660 | /// <summary> | ||
661 | /// Updates the AABBMin and AABBMax values after area/shape modification of parcel | ||
662 | /// </summary> | ||
663 | private void updateAABBAndAreaValues() | ||
664 | { | ||
665 | int min_x = 64; | ||
666 | int min_y = 64; | ||
667 | int max_x = 0; | ||
668 | int max_y = 0; | ||
669 | int tempArea = 0; | ||
670 | int x, y; | ||
671 | for (x = 0; x < 64; x++) | ||
672 | { | ||
673 | for (y = 0; y < 64; y++) | ||
674 | { | ||
675 | if (parcelBitmap[x, y] == true) | ||
676 | { | ||
677 | if (min_x > x) min_x = x; | ||
678 | if (min_y > y) min_y = y; | ||
679 | if (max_x < x) max_x = x; | ||
680 | if (max_y < y) max_y = y; | ||
681 | tempArea += 16; //16sqm parcel | ||
682 | } | ||
683 | } | ||
684 | } | ||
685 | parcelData.AABBMin = new LLVector3((float)(min_x * 4), (float)(min_y * 4), m_world.Terrain[(min_x * 4), (min_y * 4)]); | ||
686 | parcelData.AABBMax = new LLVector3((float)(max_x * 4), (float)(max_y * 4), m_world.Terrain[(max_x * 4), (max_y * 4)]); | ||
687 | parcelData.area = tempArea; | ||
688 | } | ||
689 | |||
690 | public void updateParcelBitmapByteArray() | ||
691 | { | ||
692 | parcelData.parcelBitmapByteArray = convertParcelBitmapToBytes(); | ||
693 | } | ||
694 | |||
695 | /// <summary> | ||
696 | /// Update all settings in parcel such as area, bitmap byte array, etc | ||
697 | /// </summary> | ||
698 | public void forceUpdateParcelInfo() | ||
699 | { | ||
700 | this.updateAABBAndAreaValues(); | ||
701 | this.updateParcelBitmapByteArray(); | ||
702 | } | ||
703 | |||
704 | public void setParcelBitmapFromByteArray() | ||
705 | { | ||
706 | parcelBitmap = convertBytesToParcelBitmap(); | ||
707 | } | ||
708 | #endregion | ||
709 | |||
710 | |||
711 | #region Parcel Bitmap Functions | ||
712 | /// <summary> | ||
713 | /// Sets the parcel's bitmap manually | ||
714 | /// </summary> | ||
715 | /// <param name="bitmap">64x64 block representing where this parcel is on a map</param> | ||
716 | public void setParcelBitmap(bool[,] bitmap) | ||
717 | { | ||
718 | if (bitmap.GetLength(0) != 64 || bitmap.GetLength(1) != 64 || bitmap.Rank != 2) | ||
719 | { | ||
720 | //Throw an exception - The bitmap is not 64x64 | ||
721 | throw new Exception("Error: Invalid Parcel Bitmap"); | ||
722 | } | ||
723 | else | ||
724 | { | ||
725 | //Valid: Lets set it | ||
726 | parcelBitmap = bitmap; | ||
727 | forceUpdateParcelInfo(); | ||
728 | |||
729 | } | ||
730 | } | ||
731 | /// <summary> | ||
732 | /// Gets the parcels bitmap manually | ||
733 | /// </summary> | ||
734 | /// <returns></returns> | ||
735 | public bool[,] getParcelBitmap() | ||
736 | { | ||
737 | return parcelBitmap; | ||
738 | } | ||
739 | /// <summary> | ||
740 | /// Converts the parcel bitmap to a packet friendly byte array | ||
741 | /// </summary> | ||
742 | /// <returns></returns> | ||
743 | private byte[] convertParcelBitmapToBytes() | ||
744 | { | ||
745 | byte[] tempConvertArr = new byte[512]; | ||
746 | byte tempByte = 0; | ||
747 | int x, y, i, byteNum = 0; | ||
748 | i = 0; | ||
749 | for (y = 0; y < 64; y++) | ||
750 | { | ||
751 | for (x = 0; x < 64; x++) | ||
752 | { | ||
753 | tempByte = Convert.ToByte(tempByte | Convert.ToByte(parcelBitmap[x, y]) << (i++ % 8)); | ||
754 | if (i % 8 == 0) | ||
755 | { | ||
756 | tempConvertArr[byteNum] = tempByte; | ||
757 | tempByte = (byte)0; | ||
758 | i = 0; | ||
759 | byteNum++; | ||
760 | } | ||
761 | } | ||
762 | } | ||
763 | return tempConvertArr; | ||
764 | } | ||
765 | |||
766 | private bool[,] convertBytesToParcelBitmap() | ||
767 | { | ||
768 | bool[,] tempConvertMap = new bool[64, 64]; | ||
769 | tempConvertMap.Initialize(); | ||
770 | byte tempByte = 0; | ||
771 | int x = 0, y = 0, i = 0, bitNum = 0; | ||
772 | for (i = 0; i < 512; i++) | ||
773 | { | ||
774 | tempByte = parcelData.parcelBitmapByteArray[i]; | ||
775 | for (bitNum = 0; bitNum < 8; bitNum++) | ||
776 | { | ||
777 | bool bit = Convert.ToBoolean(Convert.ToByte(tempByte >> bitNum) & (byte)1); | ||
778 | tempConvertMap[x, y] = bit; | ||
779 | x++; | ||
780 | if (x > 63) | ||
781 | { | ||
782 | x = 0; | ||
783 | y++; | ||
784 | } | ||
785 | |||
786 | } | ||
787 | |||
788 | } | ||
789 | return tempConvertMap; | ||
790 | } | ||
791 | /// <summary> | ||
792 | /// Full sim parcel creation | ||
793 | /// </summary> | ||
794 | /// <returns></returns> | ||
795 | public static bool[,] basicFullRegionParcelBitmap() | ||
796 | { | ||
797 | return getSquareParcelBitmap(0, 0, 256, 256); | ||
798 | } | ||
799 | |||
800 | /// <summary> | ||
801 | /// Used to modify the bitmap between the x and y points. Points use 64 scale | ||
802 | /// </summary> | ||
803 | /// <param name="start_x"></param> | ||
804 | /// <param name="start_y"></param> | ||
805 | /// <param name="end_x"></param> | ||
806 | /// <param name="end_y"></param> | ||
807 | /// <returns></returns> | ||
808 | public static bool[,] getSquareParcelBitmap(int start_x, int start_y, int end_x, int end_y) | ||
809 | { | ||
810 | |||
811 | bool[,] tempBitmap = new bool[64, 64]; | ||
812 | tempBitmap.Initialize(); | ||
813 | |||
814 | tempBitmap = modifyParcelBitmapSquare(tempBitmap, start_x, start_y, end_x, end_y, true); | ||
815 | return tempBitmap; | ||
816 | } | ||
817 | |||
818 | /// <summary> | ||
819 | /// Change a parcel's bitmap at within a square and set those points to a specific value | ||
820 | /// </summary> | ||
821 | /// <param name="parcel_bitmap"></param> | ||
822 | /// <param name="start_x"></param> | ||
823 | /// <param name="start_y"></param> | ||
824 | /// <param name="end_x"></param> | ||
825 | /// <param name="end_y"></param> | ||
826 | /// <param name="set_value"></param> | ||
827 | /// <returns></returns> | ||
828 | public static bool[,] modifyParcelBitmapSquare(bool[,] parcel_bitmap, int start_x, int start_y, int end_x, int end_y, bool set_value) | ||
829 | { | ||
830 | if (parcel_bitmap.GetLength(0) != 64 || parcel_bitmap.GetLength(1) != 64 || parcel_bitmap.Rank != 2) | ||
831 | { | ||
832 | //Throw an exception - The bitmap is not 64x64 | ||
833 | throw new Exception("Error: Invalid Parcel Bitmap in modifyParcelBitmapSquare()"); | ||
834 | } | ||
835 | |||
836 | int x, y; | ||
837 | for (y = 0; y < 64; y++) | ||
838 | { | ||
839 | for (x = 0; x < 64; x++) | ||
840 | { | ||
841 | if (x >= start_x / 4 && x < end_x / 4 | ||
842 | && y >= start_y / 4 && y < end_y / 4) | ||
843 | { | ||
844 | parcel_bitmap[x, y] = set_value; | ||
845 | } | ||
846 | } | ||
847 | } | ||
848 | return parcel_bitmap; | ||
849 | } | ||
850 | /// <summary> | ||
851 | /// Join the true values of 2 bitmaps together | ||
852 | /// </summary> | ||
853 | /// <param name="bitmap_base"></param> | ||
854 | /// <param name="bitmap_add"></param> | ||
855 | /// <returns></returns> | ||
856 | public static bool[,] mergeParcelBitmaps(bool[,] bitmap_base, bool[,] bitmap_add) | ||
857 | { | ||
858 | if (bitmap_base.GetLength(0) != 64 || bitmap_base.GetLength(1) != 64 || bitmap_base.Rank != 2) | ||
859 | { | ||
860 | //Throw an exception - The bitmap is not 64x64 | ||
861 | throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_base in mergeParcelBitmaps"); | ||
862 | } | ||
863 | if (bitmap_add.GetLength(0) != 64 || bitmap_add.GetLength(1) != 64 || bitmap_add.Rank != 2) | ||
864 | { | ||
865 | //Throw an exception - The bitmap is not 64x64 | ||
866 | throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_add in mergeParcelBitmaps"); | ||
867 | |||
868 | } | ||
869 | |||
870 | int x, y; | ||
871 | for (y = 0; y < 64; y++) | ||
872 | { | ||
873 | for (x = 0; x < 64; x++) | ||
874 | { | ||
875 | if (bitmap_add[x, y]) | ||
876 | { | ||
877 | bitmap_base[x, y] = true; | ||
878 | } | ||
879 | } | ||
880 | } | ||
881 | return bitmap_base; | ||
882 | } | ||
883 | #endregion | ||
884 | |||
885 | #endregion | ||
886 | |||
887 | |||
888 | } | ||
889 | #endregion | ||
890 | |||
891 | |||
892 | } | ||