cpc.java

这个游戏的关卡使用mapwin制作的

							.addElement(MyGameCanvas.instance.cpc2);
					MyGameCanvas.instance.cpc2 = null;

				}
			}
		}
			break;
		case B_VAR_BOX: {
			if (isHandleByNPC) {
				nX = MyGameCanvas.instance.npcLisa.nX;
				nY = MyGameCanvas.instance.npcLisa.nY;
			}

		}
			break;

		case B_VAR_WORM: {
			if (nSleepTime > 0) {
				nSleepTime--;
				// FIRE
				if (isLisaNear(40)) {
					// setSleep(0);
					nTimerMax = 10;
					if (nTimer++ > nTimerMax) {
						nTimer = 0;
						// FIRE,更细致的刻画
						MyGameCanvas.instance.cpc2 = new CPC(
								(byte) CPC.B_VAR_MAGIC_CPC_FIRE_BALL);
						MyGameCanvas.instance.cpc2.initBasic("BALL", 16, 20,
								bDirection, 4, true, true, 0);
						switch (bDirection) {
						case Canvas.UP: {
							MyGameCanvas.instance.cpc2
									.initAbsXY(nX + 4, nY + 9);
						}
							break;
						case Canvas.DOWN: {
							MyGameCanvas.instance.cpc2.initAbsXY(nX + 4,
									nY + 16);
						}
							break;
						case Canvas.LEFT: {
							MyGameCanvas.instance.cpc2
									.initAbsXY(nX - 9, nY + 4);
						}
							break;
						case Canvas.RIGHT: {
							MyGameCanvas.instance.cpc2.initAbsXY(nX + 16,
									nY + 4);
						}
							break;
						}
						MyGameCanvas.instance.cpc2.initParam(50, 50, 50, 50,
								50, 50, 2, 2);
						MyGameCanvas.instance.cpc2.initAnim(null);
						MyGameCanvas.instance.vecticUnits
								.addElement(MyGameCanvas.instance.cpc2);
						MyGameCanvas.instance.cpc2 = null;
					}
				}
			} else {
				int t_x = nX;
				int t_y = nY;
				switch (bDirection) {
				case Canvas.UP: {
					t_y -= nSpeed;
				}
					break;
				case Canvas.DOWN: {
					t_y += nSpeed;
				}
					break;
				case Canvas.LEFT: {
					t_x -= nSpeed;
				}
					break;
				case Canvas.RIGHT: {
					t_x += nSpeed;
				}
					break;

				}

				if (!isCollosionAnything(t_x, t_y)
						&& nLength < N_RABIT_TRAC_LENGTH
								+ MyGameCanvas.instance.getRandomInt(0, 5, 0)) {
					nX = t_x;
					nY = t_y;
					nLength++;
					if (t_x % Consts.SN_TILE_WIDTH == 0
							&& t_y % Consts.SN_TILE_HEIGHT == 0) {
						if (N_RABIT_TRAC_LENGTH - nLength < Consts.SN_TILE_WIDTH) {
							nLength = N_RABIT_TRAC_LENGTH;
							setSleep(1);
							nLength = 0;
							if (nSpeed != 0) {
								N_RABIT_TRAC_LENGTH = (short) ((Consts.SN_TILE_HEIGHT / nSpeed) * MyGameCanvas.instance
										.getRandomInt(1, 6, (int) nX + nY));
								if (bDirection == Canvas.LEFT
										|| bDirection == Canvas.RIGHT) {
									N_RABIT_TRAC_LENGTH += Consts.SN_TILE_WIDTH
											- (nX % Consts.SN_TILE_WIDTH);
								} else if (bDirection == Canvas.UP
										|| bDirection == Canvas.DOWN) {
									N_RABIT_TRAC_LENGTH += Consts.SN_TILE_HEIGHT
											- (nX % Consts.SN_TILE_HEIGHT);
								}

							} else {
								N_RABIT_TRAC_LENGTH = 20;
							}
							boolean flags[] = getDirCanGo(nX, nY);
							int tl = 0;
							byte dir[] = new byte[4];
							for (int i = 0; i < flags.length; i++) {

								if (flags[i]) {
									if (i == 0) {
										dir[tl] = Canvas.UP;
									}
									if (i == 1) {
										dir[tl] = Canvas.DOWN;
									}
									if (i == 2) {
										dir[tl] = Canvas.LEFT;
									}
									if (i == 3) {
										dir[tl] = Canvas.RIGHT;
									}

									tl++;
								}
							}
							// 随机
							if (tl == 0) {

							} else {
								int key = MyGameCanvas.instance.getRandomInt(0,
										tl - 1, 1);
								bDirection = dir[key];
								anim.changeAction(bDirection);
							}

						}
					}

				} else {
					setSleep(1);
					nLength = 0;
					if (nSpeed != 0) {
						N_RABIT_TRAC_LENGTH = (short) ((Consts.SN_TILE_HEIGHT / nSpeed) * MyGameCanvas.instance
								.getRandomInt(1, 6, (int) nX + nY));
						if (bDirection == Canvas.LEFT
								|| bDirection == Canvas.RIGHT) {
							N_RABIT_TRAC_LENGTH += Consts.SN_TILE_WIDTH
									- (nX % Consts.SN_TILE_WIDTH);
						} else if (bDirection == Canvas.UP
								|| bDirection == Canvas.DOWN) {
							N_RABIT_TRAC_LENGTH += Consts.SN_TILE_HEIGHT
									- (nX % Consts.SN_TILE_HEIGHT);
						}

					} else {
						N_RABIT_TRAC_LENGTH = 20;
					}
					boolean flags[] = getDirCanGo(nX, nY);
					int tl = 0;
					byte dir[] = new byte[4];
					for (int i = 0; i < flags.length; i++) {

						if (flags[i]) {
							if (i == 0) {
								dir[tl] = Canvas.UP;
							}
							if (i == 1) {
								dir[tl] = Canvas.DOWN;
							}
							if (i == 2) {
								dir[tl] = Canvas.LEFT;
							}
							if (i == 3) {
								dir[tl] = Canvas.RIGHT;
							}

							tl++;
						}
					}
					// 随机
					if (tl == 0) {

					} else {
						int key = MyGameCanvas.instance.getRandomInt(0, tl - 1,
								1);
						bDirection = dir[key];
						anim.changeAction(bDirection);
					}

				}

			}

		}
			break;
		case B_VAR_MAGIC_CPC_FIRE_BALL: {
			if (nLength > 128) {
				nHP = 0;
			}
			if (nX <= 0 || nY <= 0 || nX >= MyGameCanvas.snMapWidth
					|| nY >= MyGameCanvas.snMapHeight) {
				nHP = 0;
			} else {
				if (!isTileXYNull(nX / Consts.SN_TILE_WIDTH, nY
						/ Consts.SN_TILE_HEIGHT)) {
					nHP = 0;
				}
			}

			isCollosionAnything(nX, nY);
			switch (bDirection) {
			case Canvas.UP: {

				nY -= nSpeed;

			}
				break;
			case Canvas.DOWN: {

				nY += nSpeed;
			}
				break;
			case Canvas.LEFT: {

				nX -= nSpeed;
			}
				break;
			case Canvas.RIGHT: {

				nX += nSpeed;
			}
				break;

			}
			nLength++;

		}
			break;
		case B_VAR_RABIT: {
			if (nSleepTime > 0) {
				nSleepTime--;
			} else {
				int t_x = nX;
				int t_y = nY;
				switch (bDirection) {
				case Canvas.UP: {
					t_y -= nSpeed;
				}
					break;
				case Canvas.DOWN: {
					t_y += nSpeed;
				}
					break;
				case Canvas.LEFT: {
					t_x -= nSpeed;
				}
					break;
				case Canvas.RIGHT: {
					t_x += nSpeed;
				}
					break;

				}

				if (!isCollosionAnything(t_x, t_y)
						&& nLength < N_RABIT_TRAC_LENGTH) {
					nX = t_x;
					nY = t_y;
					nLength++;
					if (t_x % Consts.SN_TILE_WIDTH == 0
							&& t_y % Consts.SN_TILE_HEIGHT == 0) {
						if (N_RABIT_TRAC_LENGTH - nLength < Consts.SN_TILE_WIDTH) {
							nLength = N_RABIT_TRAC_LENGTH;

							setSleep(1);
							nLength = 0;
							N_RABIT_TRAC_LENGTH = (short) ((Consts.SN_TILE_HEIGHT / nSpeed) * MyGameCanvas.instance
									.getRandomInt(1, 6, (int) nX + nY));

							boolean flags[] = getDirCanGo(nX, nY);
							if (bDirection == Canvas.UP) {
								if (flags[3]) {
									bDirection = Canvas.RIGHT;
								} else {
									boolean flag1 = false;
									if (flags[1]) {
										flag1 = true;
										bDirection = Canvas.DOWN;
									}
									if (flags[2]) {
										flag1 = true;
										bDirection = Canvas.LEFT;
									}
									if (!flag1) {
										setSleep(0);
									}

								}
							} else if (bDirection == Canvas.DOWN) {
								if (flags[2]) {
									bDirection = Canvas.LEFT;
								} else {
									boolean flag1 = false;
									if (flags[0]) {
										flag1 = true;
										bDirection = Canvas.UP;
									}

									if (flags[3]) {
										flag1 = true;
										bDirection = Canvas.RIGHT;
									}

									if (!flag1) {
										setSleep(0);
									}

								}
							} else if (bDirection == Canvas.LEFT) {

								if (flags[0]) {
									bDirection = Canvas.UP;
								} else {
									boolean flag1 = false;
									if (flags[1]) {
										flag1 = true;
										bDirection = Canvas.DOWN;
									}
									if (flags[3]) {
										flag1 = true;
										bDirection = Canvas.RIGHT;
									}

									if (!flag1) {
										setSleep(0);
									}

								}
							} else if (bDirection == Canvas.RIGHT) {
								if (flags[1]) {
									bDirection = Canvas.DOWN;
								} else {
									boolean flag1 = false;
									if (flags[0]) {
										flag1 = true;
										bDirection = Canvas.UP;
									}

									if (flags[2]) {
										flag1 = true;
										bDirection = Canvas.LEFT;
									}

									if (!flag1) {
										setSleep(0);
									}

								}
							}
							anim.changeAction(bDirection);

						}
					}
				} else {
					setSleep(1);
					nLength = 0;
					N_RABIT_TRAC_LENGTH = (short) ((Consts.SN_TILE_HEIGHT / nSpeed) * MyGameCanvas.instance
							.getRandomInt(1, 6, (int) nX + nY));

					boolean flags[] = getDirCanGo(nX, nY);
					if (bDirection == Canvas.UP) {
						if (flags[3]) {
							bDirection = Canvas.RIGHT;
						} else {
							boolean flag1 = false;
							if (flags[1]) {
								flag1 = true;
								bDirection = Canvas.DOWN;
							}
							if (flags[2]) {
								flag1 = true;
								bDirection = Canvas.LEFT;
							}
							if (!flag1) {
								setSleep(0);
							}

						}
					} else if (bDirection == Canvas.DOWN) {
						if (flags[2]) {
							bDirection = Canvas.LEFT;
						} else {
							boolean flag1 = false;
							if (flags[0]) {
								flag1 = true;
								bDirection = Canvas.UP;
							}

							if (flags[3]) {
								flag1 = true;
								bDirection = Canvas.RIGHT;
							}

							if (!flag1) {
								setSleep(0);
							}

						}
					} else if (bDirection == Canvas.LEFT) {
						// Consts.log("left ...");
						if (flags[0]) {
							bDirection = Canvas.UP;
						} else {
							boolean flag1 = false;
							if (flags[1]) {
								flag1 = true;
								bDirection = Canvas.DOWN;
							}
							if (flags[3]) {
								flag1 = true;
								bDirection = Canvas.RIGHT;
							}

							if (!flag1) {
								setSleep(0);
							}

						}
					} else if (bDirection == Canvas.RIGHT) {
						if (flags[1]) {
							bDirection = Canvas.DOWN;
						} else {
							boolean flag1 = false;
							if (flags[0]) {
								flag1 = true;
								bDirection = Canvas.UP;
							}

							if (flags[2]) {
								flag1 = true;
								bDirection = Canvas.LEFT;
							}

							if (!flag1) {
								setSleep(0);
							}

						}
					}
					anim.changeAction(bDirection);
				}
			}

		}
			break;
		case B_VAR_MAGIC_LISA_FIRE: {
			anim.update();
			switch (bDirection) {
			case Canvas.UP: {
				nY -= nSpeed;

			}
				break;
			case Canvas.DOWN: {
				nY += nSpeed;
			}
				break;
			case Canvas.LEFT: {
				nX -= nSpeed;
			}
				break;
			case Canvas.RIGHT: {
				nX += nSpeed;
			}
				break;

			}
			nLength++;
			if (nLength > 128) {
				nHP = 0;
			}
			if (nX <= 0 || nY <= 0 || nX >= MyGameCanvas.snMapWidth
					|| nY >= MyGameCanvas.snMapHeight) {
				nHP = 0;
			}
			isCollosionAnything(nX, nY);
		}
			break;
		case B_VAR_SAVING: {
		}
			break;
		case B_VAR_DOOR: {
		}
			break;
		case B_VAR_OGRE: {
			// ogre
			// 1 -> up
			// 6 -> down
			// 2 -> left
			// 5 -> right
			//
			int t_direct = bDirection;
			if ((bDirection == Canvas.UP || bDirection == Canvas.DOWN)
					&& yCalc % MyGameCanvas.instance.nTileHeightForCalc == 0
					|| (bDirection == Canvas.LEFT || bDirection == Canvas.RIGHT)
					&& xCalc % MyGameCanvas.instance.nTileWidthForCalc == 0
					|| bDirection == -1) {
				// 拐角
				byte t_direction_1d[] = new byte[5];
				t_direction_1d[0] = -1;
				int p_direction1d = 1;
				int t_ai_alpha = 0;
				int t_ogre_x = nX / MyGameCanvas.instance.nTileWidth;
				int t_ogre_y = nY / MyGameCanvas.instance.nTileHeight;
				if (isTileXYNull(t_ogre_x, t_ogre_y - 1)
						&& isCanOGREMOVETO(t_ogre_x, t_ogre_y - 1)) {
					// up
					int t_var = 30;
					if (bDirection == Canvas.DOWN) { // down
						t_var -= 20;
					} else if (nY - MyGameCanvas.instance.npcLisa.nY <= 0) { // 在目标区域上方
						t_var -= 10;
					}
					if (t_var > t_ai_alpha) { // up
						t_ai_alpha = t_var;
						t_direction_1d[0] = Canvas.UP;
						p_direction1d = 1;
					} else if (t_var == t_ai_alpha) { //
						t_direction_1d[p_direction1d] = 1;
						p_direction1d++;
					}
				}
				if (isTileXYNull(t_ogre_x, t_ogre_y + 1)
						&& isCanOGREMOVETO(t_ogre_x, t_ogre_y + 1)) { // down

					int t_var = 30;
					if (bDirection == Canvas.UP) { // up
						t_var -= 20;
					} else if (MyGameCanvas.instance.npcLisa.nY - nY <= 0) { // 在目标上面
						t_var -= 10;
					}
					if (t_var > t_ai_alpha) {
						t_ai_alpha = t_var;
						t_direction_1d[0] = Canvas.DOWN; // down
						p_direction1d = 1;
					} else if (t_var == t_ai_alpha) { // down

						t_direction_1d[p_direction1d] = Canvas.DOWN;
						p_direction1d++;
					}
				}
				if (isTileXYNull(t_ogre_x - 1, t_ogre_y)
						&& isCanOGREMOVETO(t_ogre_x - 1, t_ogre_y)) {
					// left
					int t_var = 30;
					if (bDirection == Canvas.RIGHT) { // right
						t_var -= 20;
					} else if (nX - MyGameCanvas.instance.npcLisa.nX <= 0) {
						t_var -= 10;
					}
					if (t_var > t_ai_alpha) {
						t_ai_alpha = t_var;
						t_direction_1d[0] = Canvas.LEFT; // left