hoeruputils/secretdoor/Door.java

package dk.thoerup.bukkit.hoeruputils.secretdoor;

import java.util.Map;

import org.bukkit.Material;
import org.bukkit.Location;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.block.Block;


class Door {
        final static int EAST = 0;
        final static int WEST = 1;
        final static int NORTH = 2;
        final static int SOUTH = 3;
        
        private Location leftUpper;

        
        private Location blocks[][]; // [width][height] - [0][0] == leftUpper
        private int material[][];
        private byte data[][];
        
        private int direction;
        
        private int width;
        private int height;

        private String owner;

        private boolean isPrivate;
        

        public Door(Block sign, int width, int height, DoorStorage store, String owner, boolean isPrivate) throws ConflictingDoorException{
                leftUpper = sign.getLocation().clone();
                
                this.width = width;
                this.height = height;

                this.owner = owner;

                this.isPrivate = isPrivate;
                

                direction = sign.getData() - 2;
                
                switch ( sign.getData() ) {
                case 2: //facing east
                        leftUpper.setZ( leftUpper.getZ() + 1 ); 
                        break;  
                case 3: //facing west
                        leftUpper.setZ( leftUpper.getZ() - 1 );
                        break;
                case 4: //facing north
                        leftUpper.setX( leftUpper.getX() + 1);
                        break;
                case 5: //facing south
                        leftUpper.setX( leftUpper.getX() - 1);
                        break;
                }

                
                //material = leftUpper.getBlock().getTypeId();
                
                loadBlocks();
                
        
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {
                                Door d = store.findDoor( blocks[w][h] );
                                if (d != null) {
                                        throw new ConflictingDoorException();
                                }
                        }
                }

        }

/*
        @Deprecated
        public Door(String input, Server server) {
                String parts[] = input.split(":");

                World w = server.getWorld( parts[0] );

                leftUpper  = new Location(w, Integer.parseInt(parts[1]),  Integer.parseInt(parts[2]),  Integer.parseInt(parts[3]) );
                direction = Integer.parseInt( parts[4] );
                //material = Integer.parseInt( parts[5] );
                
                width = Integer.parseInt( parts[6] );
                height = Integer.parseInt( parts[7] );
                owner = parts[8];

                
                loadBlocks();
        }*/

        public Door(Location loc, int direction, int width, int height, String owner, boolean isPrivate) {
                leftUpper = loc;
                this.direction = direction;
                this.width = width;
                this.height = height;
                this.owner = owner;
                this.isPrivate = isPrivate;

                loadBlocks();
        }

        
        public void powerChange(World world, int oldCurrent, int newCurrent ) {
                if (isPowered() == true) {
                        open();
                } else {
                        close();
                }       
        }

        public boolean isPowered() {
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {
                                Block b = blocks[w][h].getBlock();

                                if ( b.isBlockPowered() ||  b.isBlockIndirectlyPowered() )
                                        return true;
                        }
                }
                        
                return false;
        }
        
        private void loadBlocks() {
                blocks = new Location[width][height];           
                material = new int[width][height];              
                data = new byte[width][height];         
                
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {
                                int x = leftUpper.getBlockX();
                                int y = leftUpper.getBlockY();
                                int z = leftUpper.getBlockZ();
                                switch(direction) {
                                case EAST:
                                        x -= w;
                                        break;
                                case WEST:
                                        x += w;
                                        break;                                  
                                case NORTH:
                                        z += w;
                                        break;
                                case SOUTH:
                                        z -= w;
                                        break;
                                default:
                                        System.out.println("[SecretDoor] this should never happen");                            
                                }
                                y -= h;
                                
                                //System.out.println("Add block: " + x + ":" + y + ":" + z);
                                
                                blocks[w][h] = new Location( leftUpper.getWorld(), x, y, z);

                                material[w][h] = blocks[w][h].getBlock().getTypeId();
                                data[w][h] = blocks[w][h].getBlock().getData();
                                
                        }
                }
                
        }

/*      public String toCsv() {
                StringBuilder sb = new StringBuilder();
                sb.append( leftUpper.getWorld().getName() );

                sb.append( ":" + leftUpper.getBlockX() );
                sb.append( ":" + leftUpper.getBlockY() );
                sb.append( ":" + leftUpper.getBlockZ() );
                
                sb.append( ":" + direction );

                sb.append( ":" + material[0][0] );
                
                sb.append( ":" + width );
                sb.append( ":" + height );
                sb.append( ":" + owner);

                return sb.toString();
        }*/


        public void registerMap(Map<Location,Door> map) {
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {
                                map.put(blocks[w][h], this);
                        }
                }
        }

        public void unregisterMap(Map<Location,Door> map) {
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {
                                map.remove( blocks[w][h] );
                        }
                }

        }

        public void open() {
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {                          
                                //blocks[w][h].getBlock().setTypeId( 0, false);
                                blocks[w][h].getBlock().setType( Material.AIR );
                        }
                }

        }

        public void close() {
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {                          
                                blocks[w][h].getBlock().setTypeIdAndData( material[w][h], data[w][h], true );
                        }
                }
        }


        /////// setters and getters
        public String getOwner() {
                return owner;
        }

        public Location getLeftUpper() {
                return leftUpper;
        }

        public int getWidth() {
                return width;
        }

        public int getHeight() {
                return height;
        }

        public int getDirection() {
                return direction;
        }

        public boolean isPrivate() {
                return isPrivate;
        }

}
1	package dk.thoerup.bukkit.hoeruputils.secretdoor;
2
3	import java.util.Map;
4
5	import org.bukkit.Material;
6	import org.bukkit.Location;
7	import org.bukkit.Server;
8	import org.bukkit.World;
9	import org.bukkit.block.Block;
10
11
12	class Door {
13	final static int EAST = 0;
14	final static int WEST = 1;
15	final static int NORTH = 2;
16	final static int SOUTH = 3;
17
18	private Location leftUpper;
19
20
21	private Location blocks[][]; // [width][height] - [0][0] == leftUpper
22	private int material[][];
23	private byte data[][];
24
25	private int direction;
26
27	private int width;
28	private int height;
29
30	private String owner;
31
32	private boolean isPrivate;
33
34
35	public Door(Block sign, int width, int height, DoorStorage store, String owner, boolean isPrivate) throws ConflictingDoorException{
36	leftUpper = sign.getLocation().clone();
37
38	this.width = width;
39	this.height = height;
40
41	this.owner = owner;
42
43	this.isPrivate = isPrivate;
44
45
46	direction = sign.getData() - 2;
47
48	switch ( sign.getData() ) {
49	case 2: //facing east
50	leftUpper.setZ( leftUpper.getZ() + 1 );
51	break;
52	case 3: //facing west
53	leftUpper.setZ( leftUpper.getZ() - 1 );
54	break;
55	case 4: //facing north
56	leftUpper.setX( leftUpper.getX() + 1);
57	break;
58	case 5: //facing south
59	leftUpper.setX( leftUpper.getX() - 1);
60	break;
61	}
62
63
64
65	//material = leftUpper.getBlock().getTypeId();
66
67	loadBlocks();
68
69
70	for (int w=0; w<width; w++) {
71	for (int h=0; h<height; h++) {
72	Door d = store.findDoor( blocks[w][h] );
73	if (d != null) {
74	throw new ConflictingDoorException();
75	}
76	}
77	}
78
79	}
80
81	/*
82	@Deprecated
83	public Door(String input, Server server) {
84	String parts[] = input.split(":");
85
86	World w = server.getWorld( parts[0] );
87
88	leftUpper = new Location(w, Integer.parseInt(parts[1]), Integer.parseInt(parts[2]), Integer.parseInt(parts[3]) );
89	direction = Integer.parseInt( parts[4] );
90	//material = Integer.parseInt( parts[5] );
91
92	width = Integer.parseInt( parts[6] );
93	height = Integer.parseInt( parts[7] );
94	owner = parts[8];
95
96
97	loadBlocks();
98	}*/
99
100	public Door(Location loc, int direction, int width, int height, String owner, boolean isPrivate) {
101	leftUpper = loc;
102	this.direction = direction;
103	this.width = width;
104	this.height = height;
105	this.owner = owner;
106	this.isPrivate = isPrivate;
107
108	loadBlocks();
109	}
110
111
112
113	public void powerChange(World world, int oldCurrent, int newCurrent ) {
114	if (isPowered() == true) {
115	open();
116	} else {
117	close();
118	}
119	}
120
121	public boolean isPowered() {
122	for (int w=0; w<width; w++) {
123	for (int h=0; h<height; h++) {
124	Block b = blocks[w][h].getBlock();
125
126	if ( b.isBlockPowered() \|\| b.isBlockIndirectlyPowered() )
127	return true;
128	}
129	}
130
131	return false;
132	}
133
134	private void loadBlocks() {
135	blocks = new Location[width][height];
136	material = new int[width][height];
137	data = new byte[width][height];
138
139	for (int w=0; w<width; w++) {
140	for (int h=0; h<height; h++) {
141	int x = leftUpper.getBlockX();
142	int y = leftUpper.getBlockY();
143	int z = leftUpper.getBlockZ();
144	switch(direction) {
145	case EAST:
146	x -= w;
147	break;
148	case WEST:
149	x += w;
150	break;
151	case NORTH:
152	z += w;
153	break;
154	case SOUTH:
155	z -= w;
156	break;
157	default:
158	System.out.println("[SecretDoor] this should never happen");
159	}
160	y -= h;
161
162	//System.out.println("Add block: " + x + ":" + y + ":" + z);
163
164	blocks[w][h] = new Location( leftUpper.getWorld(), x, y, z);
165
166	material[w][h] = blocks[w][h].getBlock().getTypeId();
167	data[w][h] = blocks[w][h].getBlock().getData();
168
169	}
170	}
171
172	}
173
174	/* public String toCsv() {
175	StringBuilder sb = new StringBuilder();
176	sb.append( leftUpper.getWorld().getName() );
177
178	sb.append( ":" + leftUpper.getBlockX() );
179	sb.append( ":" + leftUpper.getBlockY() );
180	sb.append( ":" + leftUpper.getBlockZ() );
181
182	sb.append( ":" + direction );
183
184	sb.append( ":" + material[0][0] );
185
186	sb.append( ":" + width );
187	sb.append( ":" + height );
188	sb.append( ":" + owner);
189
190	return sb.toString();
191	}*/
192
193
194	public void registerMap(Map<Location,Door> map) {
195	for (int w=0; w<width; w++) {
196	for (int h=0; h<height; h++) {
197	map.put(blocks[w][h], this);
198	}
199	}
200	}
201
202	public void unregisterMap(Map<Location,Door> map) {
203	for (int w=0; w<width; w++) {
204	for (int h=0; h<height; h++) {
205	map.remove( blocks[w][h] );
206	}
207	}
208
209	}
210
211	public void open() {
212	for (int w=0; w<width; w++) {
213	for (int h=0; h<height; h++) {
214	//blocks[w][h].getBlock().setTypeId( 0, false);
215	blocks[w][h].getBlock().setType( Material.AIR );
216	}
217	}
218
219	}
220
221	public void close() {
222	for (int w=0; w<width; w++) {
223	for (int h=0; h<height; h++) {
224	blocks[w][h].getBlock().setTypeIdAndData( material[w][h], data[w][h], true );
225	}
226	}
227	}
228
229
230	/////// setters and getters
231	public String getOwner() {
232	return owner;
233	}
234
235	public Location getLeftUpper() {
236	return leftUpper;
237	}
238
239	public int getWidth() {
240	return width;
241	}
242
243	public int getHeight() {
244	return height;
245	}
246
247	public int getDirection() {
248	return direction;
249	}
250
251	public boolean isPrivate() {
252	return isPrivate;
253	}
254
255	}