diff --git a/src/resources/objects/SWGSet.java b/src/resources/objects/SWGSet.java
index b60a9950..1feed1d2 100644
--- a/src/resources/objects/SWGSet.java
+++ b/src/resources/objects/SWGSet.java
@@ -21,7 +21,6 @@
  ******************************************************************************/
 package resources.objects;
 
-import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
@@ -38,15 +37,15 @@ import engine.resources.objects.SWGObject;
 
 /* A SWGSet element should extend Delta or implement IDelta */
 
-public class SWGSet<E> implements Set<E>, Serializable {
+public class SWGSet<E> extends Delta implements Set<E> {
 	
 	private static final long serialVersionUID = 1L;
+	
 	private TreeSet<E> set = new TreeSet<E>();
 	private transient int updateCounter = 0;
 	private byte viewType;
 	private short updateType;
 	private boolean addByte;
-	protected transient Object objectMutex = new Object();
 	private transient SWGObject object;
 	
 	public SWGSet() { }
@@ -68,7 +67,8 @@ public class SWGSet<E> implements Set<E>, Serializable {
 	}
 	
 	public void init(SWGObject object) {
-		objectMutex = new Object();
+		super.init(object);
+		
 		updateCounter = 0;
 		this.object = object;
 		
@@ -83,130 +83,159 @@ public class SWGSet<E> implements Set<E>, Serializable {
 		}
 	}
 	
-	public synchronized boolean add(E e) {
-		if (valid(e)) {
-			if (set.add(e)) {
-				queue(item(1, e, null, true, false));
+	public boolean add(E e) {
+		synchronized(objectMutex) {
+			if (valid(e)) {
+				if (set.add(e)) {
+					queue(item(1, e, null, true, false));
+					return true;
+				}
+			}
+			
+			return false;
+		}
+	}
+	
+	public boolean addAll(Collection<? extends E> c) {
+		synchronized(objectMutex) {
+			List<byte[]> buffer = new ArrayList<byte[]>();
+			
+			for (E e : c) {
+				if (valid(e) && set.add(e)) {
+					buffer.add(item(1, e, null, true, false));
+				}
+			}
+			
+			if (buffer.size() > 0) {
+				queue(buffer);
+				return true;
+			} else {
+				return false;
+			}
+		}
+	}
+	
+	public void clear() {
+		synchronized(objectMutex) {
+			set.clear();
+			queue(item(2, null, null, false, false));
+		}
+	}
+	
+	public boolean contains(Object o) {
+		synchronized(objectMutex) {
+			return set.contains(o);
+		}
+	}
+	
+	public boolean containsAll(Collection<?> c) {
+		synchronized(objectMutex) {
+			return set.containsAll(c);
+		}
+	}
+	
+	public boolean isEmpty() {
+		synchronized(objectMutex) {
+			return set.isEmpty();
+		}
+	}
+	
+	public Iterator<E> iterator() {
+		synchronized(objectMutex) {
+			return set.iterator();
+		}
+	}
+	
+	public boolean remove(Object e) {
+		synchronized(objectMutex) {
+			if (valid(e) && set.remove(e)) {
+				queue(item(0, e, null, true, false));
 				return true;
 			}
-		}
-		
-		return false;
-	}
-	
-	public synchronized boolean addAll(Collection<? extends E> c) {
-		List<byte[]> buffer = new ArrayList<byte[]>();
-		
-		for (E e : c) {
-			if (valid(e) && set.add(e)) {
-				buffer.add(item(1, e, null, true, false));
-			}
-		}
-		
-		if (buffer.size() > 0) {
-			queue(buffer);
-			return true;
-		} else {
+			
 			return false;
 		}
 	}
 	
-	public synchronized void clear() {
-		set.clear();
-		queue(item(2, null, null, false, false));
-	}
-	
-	public synchronized boolean contains(Object o) {
-		return set.contains(o);
-	}
-	
-	public synchronized boolean containsAll(Collection<?> c) {
-		return set.containsAll(c);
-	}
-	
-	public synchronized boolean isEmpty() {
-		return set.isEmpty();
-	}
-	
-	public synchronized Iterator<E> iterator() {
-		return set.iterator();
-	}
-	
-	public synchronized boolean remove(Object e) {
-		if (valid(e) && set.remove(e)) {
-			queue(item(0, e, null, true, false));
-			return true;
-		}
-		return false;
-	}
-	
-	public synchronized boolean removeAll(Collection<?> c) {
-		List<byte[]> buffer = new ArrayList<byte[]>();
-		
-		for (Object o : c) {
-			if (valid(o) && set.remove(o)) {
-				buffer.add(item(0, o, null, true, false));
+	public boolean removeAll(Collection<?> c) {
+		synchronized(objectMutex) {
+			List<byte[]> buffer = new ArrayList<byte[]>();
+			
+			for (Object o : c) {
+				if (valid(o) && set.remove(o)) {
+					buffer.add(item(0, o, null, true, false));
+				}
+			}
+			
+			if (buffer.size() > 0) {
+				queue(buffer);
+				return true;
+			} else {
+				return false;
 			}
 		}
-		
-		if (buffer.size() > 0) {
-			queue(buffer);
-			return true;
-		} else {
-			return false;
-		}
 	}
 	
-	public synchronized boolean retainAll(Collection<?> c) {
+	public boolean retainAll(Collection<?> c) {
 		synchronized(objectMutex) {
 			return set.retainAll(c);
 		}
 	}
 	
-	public synchronized int size() {
-		return set.size();
+	public int size() {
+		synchronized(objectMutex) {
+			return set.size();
+		}
 	}
 	
-	public synchronized Object[] toArray() {
-		return set.toArray();
+	public Object[] toArray() {
+		synchronized(objectMutex) {
+			return set.toArray();
+		}
 	}
 	
-	public synchronized <T> T[] toArray(T[] a) {
-		return set.toArray(a);
+	public <T> T[] toArray(T[] a) {
+		synchronized(objectMutex) {
+			return set.toArray(a);
+		}
 	}
 	
-	public synchronized int getUpdateCounter() {
-		return updateCounter;
+	public int getUpdateCounter() {
+		synchronized(objectMutex) {
+			return updateCounter;
+		}
 	}
 	
 	public Object getMutex() {
 		return objectMutex;
 	}
 	
-	public synchronized byte[] getBytes() {
-		byte[] objects = { };
-		int size = 0;
-		
-		for (Object o : set) {
-			byte[] object = Baseline.toBytes(o);
-			size += object.length;
+	public byte[] getBytes() {
+		synchronized(objectMutex) {
+			byte[] objects = { };
+			int size = 0;
 			
-			IoBuffer buffer = Delta.createBuffer(size);
+			for (Object o : set) {
+				byte[] object = Baseline.toBytes(o);
+				size += object.length;
+				
+				IoBuffer buffer = createBuffer(size);
+				buffer.put(objects);
+				if (addByte) buffer.put((byte) 0);
+				buffer.put(object);
+				buffer.flip();
+				
+				objects = buffer.array();
+			}
+			
+			IoBuffer buffer = createBuffer(8 + size);
+			buffer.putInt(set.size());
+			buffer.putInt(updateCounter);
 			buffer.put(objects);
-			if (addByte) buffer.put((byte) 0);
-			buffer.put(object);
 			buffer.flip();
 			
-			objects = buffer.array();
+			return buffer.array();
 		}
-		
-		IoBuffer buffer = Delta.createBuffer(8 + size);
-		buffer.putInt(set.size());
-		buffer.putInt(updateCounter);
-		buffer.put(objects);
-		buffer.flip();
-		
-		return buffer.array();
 	}
 	
 	private boolean valid(Object o) {
@@ -226,7 +255,7 @@ public class SWGSet<E> implements Set<E>, Serializable {
 		
 		int size = 1 + ((useIndex) ? Baseline.toBytes(index).length : 0) + ((useData) ? data.length : 0);
 		
-		IoBuffer buffer = Delta.createBuffer(size);
+		IoBuffer buffer = createBuffer(size);
 		buffer.put((byte) type);
 		if (useIndex) buffer.put(Baseline.toBytes(index));
 		if (useData) buffer.put(data);
@@ -238,7 +267,7 @@ public class SWGSet<E> implements Set<E>, Serializable {
 	}
 	
 	private void queue(byte[] data) {
-		IoBuffer buffer = Delta.createBuffer(data.length + 8);
+		IoBuffer buffer = createBuffer(data.length + 8);
 		buffer.putInt(1);
 		buffer.putInt(updateCounter);
 		buffer.put(data);
@@ -253,7 +282,7 @@ public class SWGSet<E> implements Set<E>, Serializable {
 			size += queued.length;
 		}
 		
-		IoBuffer buffer = Delta.createBuffer(size + 8);
+		IoBuffer buffer = createBuffer(size + 8);
 		buffer.putInt(data.size());
 		buffer.putInt(updateCounter);
 		for (byte[] queued : data) buffer.put(queued);