hoeruputils/secretdoor/Door.java

package dk.thoerup.bukkit.hoeruputils.secretdoor;

import java.util.Map;

import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;


class Door {

        private Location leftUpper;

        
        private Location blockLocations[][]; // [width][height] - [0][0] == leftUpper
        private BlockState blockStates[][];
        
        private BlockFace direction;
        
        private int width;
        private int height;

        private String owner;

        private boolean isPrivate;
        
        private String password;
        

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

                this.owner = owner;

                this.isPrivate = isPrivate;
                this.password = password;
                
                BlockState signState = sign.getState();
                org.bukkit.material.Sign signData = (org.bukkit.material.Sign) signState.getData();

                direction = signData.getFacing();
                
                switch ( direction ) {
                case EAST: //facing east
                        leftUpper.setZ( leftUpper.getZ() + 1 ); 
                        break;  
                case WEST: //facing west
                        leftUpper.setZ( leftUpper.getZ() - 1 );
                        break;
                case NORTH: //facing north
                        leftUpper.setX( leftUpper.getX() + 1);
                        break;
                case SOUTH: //facing south
                        leftUpper.setX( leftUpper.getX() - 1);
                        break;
                default:
                        //DoNothing
                        break;
                }

                
                //material = leftUpper.getBlock().getTypeId();
                
                loadBlocks();
                
        
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {
                                Door d = store.findDoor( blockLocations[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, BlockFace direction, int width, int height, String owner, boolean isPrivate, String password) {
                leftUpper = loc;
                this.direction = direction;
                this.width = width;
                this.height = height;
                this.owner = owner;
                this.isPrivate = isPrivate;
                this.password = password;

                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 = blockLocations[w][h].getBlock();

                                if ( b.isBlockPowered() ||  b.isBlockIndirectlyPowered() )
                                        return true;
                        }
                }
                        
                return false;
        }
        
        private void loadBlocks() {
                blockLocations = new Location[width][height];           
                blockStates = new BlockState[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);
                                
                                blockLocations[w][h] = new Location( leftUpper.getWorld(), x, y, z);

                                blockStates[w][h] = blockLocations[w][h].getBlock().getState();
        
                        }
                }
                
        }

/*      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(blockLocations[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( blockLocations[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);
                                blockLocations[w][h].getBlock().setType( Material.AIR );
                        }
                }

        }

        public void close() {
                for (int w=0; w<width; w++) {
                        for (int h=0; h<height; h++) {                          
                                blockStates[w][h].update(true, 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 BlockFace getDirection() {
                return direction;
        }

        public boolean isPrivate() {
                return isPrivate;
        }
        
        public String getPassword() {
                return password;
        }

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