#----------------------------------------------------------------------
# 箱庭諸島 ver2.20
# ターン進行モジュール(ver1.03)
# 使用条件、使用方法等は、hako-readme.txtファイルを参照
#
# 箱庭諸島のページ: http://t.pos.to/hako/
#----------------------------------------------------------------------
# 「帝国の興亡」 ver1.0.0 by おじー http://t.pos.to/ozzy/
# 使用条件は箱庭諸島に準ずる．詳しくは付属のreadme.txtファイルを参照
#----------------------------------------------------------------------

package H2;

#周囲2ヘックスの座標
my(@ax) = (0, 1, 1, 1, 0,-1, 0, 1, 2, 2, 2, 1, 0,-1,-1,-2,-1,-1, 0);
my(@ay) = (0,-1, 0, 1, 1, 0,-1,-2,-1, 0, 1, 2, 2, 2, 1, 0,-1,-2,-2);

#----------------------------------------------------------------------
# 島の新規作成モード
#----------------------------------------------------------------------
# メイン
sub newIslandMain {
    my($i, $campNum);
    # 島がいっぱいでないかチェック
    if($H2::islandNumber >= $H2::maxIsland) {
	unlock();
	tempNewIslandFull();
	return;
    }

    # 名前があるかチェック
    if($H2::currentName eq '') {
	unlock();
	tempNewIslandNoName();
	return;
    }

    # 名前が正当かチェック
    if($H2::currentName =~ /[,\?\(\)\<\>\$]|^無人$/) {
	# 使えない名前
	unlock();
	tempNewIslandBadName();
	return;
    }

    # 陣営を決定
    if($H2::campSelectRule != 2 || $H2::campId == -1) {
        $campNum = selectCamp();
    }
    else {
	$campNum = $H2::idToCampNumber{$H2::campId};
	if ($H2::camp[$campNum]->{'number'} >= ($H2::maxIsland / $H2::campNumber)) {
	    # その陣営は満杯
	    unlock();
	    tempNewIslandFull();
	    return;
	}
    }
    $H2::currentName = $H2::camp[$campNum]->{'mark'} . $H2::currentName;

    # 名前の重複チェック
    if(nameToNumber($H2::currentName) != -1) {
	# すでに発見ずみ
	unlock();
	tempNewIslandAlready();
	return;
    }

    # passwordの存在判定
    if($H2::inputPassword eq '') {
	# password無し
	unlock();
	tempNewIslandNoPassword();
	return;
    }

    # 確認用パスワード
    if($H2::inputPassword2 ne $H2::inputPassword) {
	# password間違い
	unlock();
	tempWrongPassword();
	return;
    }


    
    # 新しい島の番号を決める
    $H2::currentNumber = $H2::islandNumber;
    $H2::islandNumber++;
    $H2::islands[$H2::currentNumber] = makeNewIsland();
    my($island) = $H2::islands[$H2::currentNumber];

    # 各種の値を設定
    $island->{'name'} = $H2::currentName;
    $island->{'score'} = $H2::camp[$campNum]->{'id'};
    $island->{'id'} = $H2::islandNextID;

    $H2::islandNextID ++;
    $island->{'absent'} = $H2::preGiveupTurn - 3;

    $island->{'comment'} = '(未登録)';
    $island->{'password'} = encode($H2::inputPassword);
    # 人口その他算出
    estimate($H2::currentNumber);
    
    # 陣営データの変更
    $H2::camp[$campNum]->{'score'} += $island->{'pop'};
    $H2::camp[$campNum]->{'number'}++;
    campOccupy();

    # データ書き出し
    writeIslandsFile($island->{'id'});
    logDiscover($H2::currentName); # ログ

    # 開放
    unlock();

    # 発見画面
    tempNewIslandHead($H2::currentName); # 発見しました!!
    islandInfo(); # 島の情報
    islandMap(1); # 島の地図、ownerモード
}

# 新しい島を作成する
sub makeNewIsland {
    # 地形を作る
    my($land, $landValue) = makeNewLand();

    # 初期コマンドを生成
    my(@command, $i);
    for($i = 0; $i < $H2::commandMax; $i++) {
	 $command[$i] = {
	     'kind' => $H2::comDoNothing,
	     'target' => 0,
	     'x' => 0,
	     'y' => 0,
	     'arg' => 0
	 };
    }

    # 初期掲示板を作成
    my(@lbbs);
    for($i = 0; $i < $H2::lbbsMax; $i++) {
	 $lbbs[$i] = "0>>";
    }

    # 島にして返す
    return {
	'land' => $land,
	'landValue' => $landValue,
	'command' => \@command,
	'lbbs' => \@lbbs,
	'money' => $H2::islandTurn == 0 ? $H2::initialMoney : $H2::initialMoney2,
	'food' =>  $H2::islandTurn == 0 ? $H2::initialFood : $H2::initialFood2,
	'prize' => '0,0,',
    };
}

# 新しい島の地形を作成する
sub makeNewLand {
    # 基本形を作成
    my(@land, @landValue, $x, $y, $i);

    # 海に初期化
    for($y = 0; $y < $H2::islandSize; $y++) {
	 for($x = 0; $x < $H2::islandSize; $x++) {
	     $land[$x][$y] = $H2::landSea;
	     $landValue[$x][$y] = 0;
	 }
    }

    # 中央の4*4に荒地を配置
    my($center) = $H2::islandSize / 2 - 1;
    for($y = $center - 1; $y < $center + 3; $y++) {
	 for($x = $center - 1; $x < $center + 3; $x++) {
	     $land[$x][$y] = $H2::landWaste;
	 }
    }

    # 8*8範囲内に陸地を増殖
    for($i = 0; $i < 120; $i++) {
	 # ランダム座標
	 $x = random(8) + $center - 3;
	 $y = random(8) + $center - 3;

	 my($tmp) = countAround(\@land, $x, $y, $H2::landSea, 7);
	 if(countAround(\@land, $x, $y, $H2::landSea, 7) != 7){
	     # 周りに陸地がある場合、浅瀬にする
	     # 浅瀬は荒地にする
	     # 荒地は平地にする
	     if($land[$x][$y] == $H2::landWaste) {
		 $land[$x][$y] = $H2::landPlains;
		 $landValue[$x][$y] = 0;
	     } else {
		 if($landValue[$x][$y] == 1) {
                     $land[$x][$y] = $H2::landWaste;
                     $landValue[$x][$y] = 0;
		 } else {
		     $landValue[$x][$y] = 1;
		 }
	     }
	 }
    }

    # 森を作る
    my($count) = 0;
    while($count < 4) {
	 # ランダム座標
	 $x = random(4) + $center - 1;
	 $y = random(4) + $center - 1;

	 # そこがすでに森でなければ、森を作る
	 if($land[$x][$y] != $H2::landForest) {
	     $land[$x][$y] = $H2::landForest;
	     $landValue[$x][$y] = 5; # 最初は500本
	     $count++;
	 }
    }

    # 町を作る
    $count = 0;
    while($count < 2) {
	 # ランダム座標
	 $x = random(4) + $center - 1;
	 $y = random(4) + $center - 1;

	 # そこが森か町でなければ、町を作る
	 if(($land[$x][$y] != $H2::landTown) &&
	    ($land[$x][$y] != $H2::landForest)) {
	     $land[$x][$y] = $H2::landTown;
	     $landValue[$x][$y] = 5; # 最初は500人
	     $count++;
	 }
    }

    # 山を作る
    $count = 0;
    while($count < 1) {
	 # ランダム座標
	 $x = random(4) + $center - 1;
	 $y = random(4) + $center - 1;

	 # そこが森か町でなければ、町を作る
	 if(($land[$x][$y] != $H2::landTown) &&
	    ($land[$x][$y] != $H2::landForest)) {
	     $land[$x][$y] = $H2::landMountain;
	     $landValue[$x][$y] = 0; # 最初は採掘場なし
	     $count++;
	 }
    }

    # 基地を作る
    $count = 0;
    while($count < 1) {
	 # ランダム座標
	 $x = random(4) + $center - 1;
	 $y = random(4) + $center - 1;

	 # そこが森か町か山でなければ、基地
	 if(($land[$x][$y] != $H2::landTown) &&
	    ($land[$x][$y] != $H2::landForest) &&
	    ($land[$x][$y] != $H2::landMountain)) {
	     $land[$x][$y] = $H2::landBase;
	     $landValue[$x][$y] = 0;
	     $count++;
	 }
    }

    return (\@land, \@landValue);
}

#----------------------------------------------------------------------
# 情報変更モード
#----------------------------------------------------------------------
# メイン
sub changeMain {
    # idから島を取得
    $H2::currentNumber = $H2::idToNumber{$H2::currentID};
    my($island) = $H2::islands[$H2::currentNumber];
    my($camp) = $H2::camp[$H2::idToCampNumber{$island->{'score'}}];
    my($flag) = 0;

    if($H2::currentID != $island->{'id'}) {
	unlock();
	tempProblem();
	return;
    }


    # パスワードチェック
    if($H2::oldPassword eq $H2::specialPassword) {
	# 特殊パスワード
	if($H2::currentName =~ /^無人$/) {
	    # 島削除モード
	    deleteIsland();
	    unlock();
	    tempDeleteIsland($island->{'name'});
	    return;
	}
	else {
	    # 食糧/資金maxモード
	    $island->{'money'} = 9999;
	    $island->{'food'} = 9999;
	}
    } elsif(!checkPassword($island->{'password'},$H2::oldPassword)) {
	# password間違い
	unlock();
	tempWrongPassword();
	return;
    }

    # 確認用パスワード
    if($H2::inputPassword2 ne $H2::inputPassword) {
	# password間違い
	unlock();
	tempWrongPassword();
	return;
    }

    if($H2::currentName ne '') {
	# 名前変更の場合	
	# 名前が正当かチェック
	if($H2::currentName =~ /[,\?\(\)\<\>]|^無人$/) {
	    # 使えない名前
	    unlock();
	    tempNewIslandBadName();
	    return;
	}

	# 陣営マークを付加
	$H2::currentName = $camp->{'mark'} . $H2::currentName;

	# 名前の重複チェック
	if(nameToNumber($H2::currentName) != -1) {
	    # すでに発見ずみ
	    unlock();
	    tempNewIslandAlready();
	    return;
	}

	if($island->{'money'} < $H2::costChangeName) {
	    # 金が足りない
	    unlock();
	    tempChangeNoMoney();
	    return;
	}

	# 代金
	if($H2::oldPassword ne $H2::specialPassword) {
	    $island->{'money'} -= $H2::costChangeName;
	}

	# 名前を変更
	logChangeName($island->{'name'}, $H2::currentName);
	$island->{'name'} = $H2::currentName;
	$flag = 1;
    }

    # password変更の場合
    if($H2::inputPassword ne '') {
	# パスワードを変更
	$island->{'password'} = encode($H2::inputPassword);
	$flag = 1;
    }

    if(($flag == 0) && ($H2::oldPassword ne $H2::specialPassword)) {
	# どちらも変更されていない
	unlock();
	tempChangeNothing();
	return;
    }

    # データ書き出し
    writeIslandsFile($H2::currentID);
    unlock();

    # 変更成功
    tempChange();
}

# 島の強制削除
sub deleteIsland {
    my($island) = $H2::islands[$H2::idToNumber{$H2::currentID}];
    my($camp) = $H2::camp[$H2::idToCampNumber{$island->{'score'}}];

    # 陣営データの操作
    $camp->{'number'} -= 1;
    $camp->{'score'} -= $island->{'pop'};
    campOccupy();
    campSort();

    # 島テーブルの操作
    $island->{'pop'} = 0;
    islandSort();

    logDeleteIsland($tmpid, $island->{'name'});

    # メインデータの操作
    $H2::islandNumber -= 1;
    writeIslandsFile($H2::currentID);
    unlink("island.$H2::currentID");
}

#----------------------------------------------------------------------
# ターン進行モード
#----------------------------------------------------------------------
# メイン
sub turnMain {
    my($noDisFlag) = 0; # 災害は発生しないフラグ

    # unitCount回ターンを進行するまで時間を足さない
    if ($H2::islandTurn % $H2::unitCount == ($H2::unitCount-1)) {
	# 最終更新時間を更新
	$H2::islandLastTime += $H2::unitTime;
	if ($H2::islandTurn < $H2::armisticeTurn) {
	    # 停戦期間は無災害
	    $noDisFlag = 1;
	}
	# 陣営毎の暗号を再計算
	remakeCampPasswd();
    } else {
	# 無災害
	$noDisFlag = 1;
    }

    if ($noDisFlag) {
	# 最後のターン以外は災害は発生しない
	$H2::disEarthquake = 0;  # 地震
	$H2::disTsunami    = 0; # 津波
	$H2::disTyphoon    = 0; # 台風
	$H2::disMeteo      = 0; # 隕石
	$H2::disHugeMeteo  = 0;  # 巨大隕石
	$H2::disEruption   = 0; # 噴火
	$H2::disFire       = 0; # 火災
	$H2::disMaizo      = 0; # 埋蔵金
	$H2::disFalldown   = 0; # 地盤沈下
	$H2::disMonster     = 0; # 怪獣
	$H2::oilRatio = 0; # 油田枯渇
    }

    # ログファイルを後ろにずらす
    my($i, $j, $s, $d);
    for($i = ($H2::logMax - 1); $i >= 0; $i--) {
	$j = $i + 1;
	my($s) = "${H2::dirName}/hakojima.log$i";
	my($d) = "${H2::dirName}/hakojima.log$j";
	unlink($d);
	rename($s, $d);
    }

    # 陣営の情勢を示すデータのクリア
    if ($unitCount < 0 || $H2::islandTurn % $H2::unitCount == 0) {
	for ($i=0; $i<$H2::campNumber; $i++) {
	    $H2::camp[$i]->{'ext'}[0] = 0; 
	    $H2::camp[$i]->{'ext'}[1] = 0; 
	    $H2::camp[$i]->{'ext'}[2] = 0; 
	}
    }

    # 陣営消滅判定
    my($remainCampNumber) = $H2::campNumber;
    if ($H2::campDeleteRule) {
	my($threshold) = 100 / $H2::campNumber / 2;
	for ($i=0; $i<$H2::campNumber; $i++) {
	    if ($H2::camp[$i]->{'occupation'} < $threshold) { 
		$H2::campDeleteFlag[$i] = 1; # 消滅フラグをセット
		$remainCampNumber--;
		logCampDelete($H2::camp[$i]->{'name'});
	    }
	}
    }
    
    # 座標配列を作る
    makeRandomPointArray();

    # ターン番号
    $H2::islandTurn++;

    # 順番決め
    my(@order) = randomArray($H2::islandNumber);
    
    # 収入、消費フェイズ
    for($i = 0; $i < $H2::islandNumber; $i++) {
	estimate($order[$i]);
	income($H2::islands[$order[$i]]);

	# ターン開始前の人口をメモる
	$H2::islands[$order[$i]]->{'oldPop'} = $H2::islands[$order[$i]]->{'pop'};
    }

    # コマンド処理
    for($i = 0; $i < $H2::islandNumber; $i++) {
	if ($H2::campDeleteFlag[$H2::idToCampNumber{$H2::islands[$order[$i]]->{'score'}}]) {
	    # 陣営消滅による島の削除)
	    $H2::islands[$order[$i]]->{'dead'} = 1;
	}
	else {
	    # 戻り値1になるまで繰り返し
	    while(doCommand($H2::islands[$order[$i]]) == 0){};
	}
    }

    # 成長および単ヘックス災害
    for($i = 0; $i < $H2::islandNumber; $i++) {
	doEachHex($H2::islands[$order[$i]]);
    }

    # 島全体処理
    my($remainNumber) = $H2::islandNumber;

    # 陣営データの初期化(再計算のため)
    for ($i = 0; $i < $H2::campNumber; $i++) {
	$H2::camp[$i]->{'score'} = 0;
	$H2::camp[$i]->{'number'} = 0;
    }    

    my($island);
    for($i = 0; $i < $H2::islandNumber; $i++) {
	$island = $H2::islands[$order[$i]];
	doIslandProcess($order[$i], $island); 

	# 死滅判定
	if($island->{'dead'} == 1) {
	    $island->{'pop'} = 0;
	    $remainNumber--;
	} elsif($island->{'pop'} == 0) {
	    $island->{'dead'} = 1;
	    $remainNumber--;
	    # 死滅メッセージ
	    my($tmpid) = $island->{'id'};
	    logDead($tmpid, $island->{'name'});
	    unlink("island.$tmpid");
	}

	# 陣営データの再計算
	my($campNum) = $H2::idToCampNumber{$island->{'score'}};
	if ($island->{'dead'} == 0) {
	    $H2::camp[$campNum]->{'score'} += $island->{'pop'};
	    $H2::camp[$campNum]->{'number'}++;

	    # 貢献度(1万人につき1ポイント)
	    $island->{'ext'}[1] += int($island->{'pop'}/10);
	}
    }

    # 陣営の占有率の計算
    campOccupy();

    # 人口順にソート
    islandSort();
    campSort();

    # ターン杯対象ターンだったら、その処理
    if(($H2::islandTurn % $H2::turnPrizeUnit) == 0) {
	my($island) = $H2::islands[0];
	logPrize($island->{'id'}, $island->{'name'}, "$H2::islandTurn$H2::prize[0]->{'name'}");
	$island->{'prize'} .= "${H2::islandTurn},";
    }

    # 島数カット
    $H2::islandNumber = $remainNumber;

    # 陣営カット(消滅ルール)
    $H2::campNumber = $remainCampNumber;

    # バックアップターンであれば、書く前にrename
    if(($H2::islandTurn % $H2::backupTurn) == 0) {
	my($i);
	my($tmp) = $H2::backupTimes - 1;
	myrmtree("${H2::dirName}.bak$tmp");
	for($i = ($H2::backupTimes - 1); $i > 0; $i--) {
	    my($j) = $i - 1;
	    rename("${H2::dirName}.bak$j", "${H2::dirName}.bak$i");
	}
	rename("${H2::dirName}", "${H2::dirName}.bak0");
	mkdir("${H2::dirName}", $H2::dirMode);

	# ログファイルだけ戻す
	for($i = 0; $i <= $H2::logMax; $i++) {
	    rename("${H2::dirName}.bak0/hakojima.log$i",
		   "${H2::dirName}/hakojima.log$i");
	}
	rename("${H2::dirName}.bak0/hakojima.his",
	       "${H2::dirName}/hakojima.his");
    }

    # 終了条件の判定
    my $n = gameOver();
    if ($H2::debug == 0 && $n != -1) {
	$H2::islandLastTime += 25920000; # 次の更新時間を1ヶ月先にする
	$H2::camp[$n]->{'name'} = '【勝者！】' . $H2::camp[$n]->{'name'};
    }

    # ファイルに書き出し
    writeIslandsFile(-1);

    # ログ書き出し
    logFlush();

    # 記録ログ調整
    logHistoryTrim();

    # トップへ
    topPageMain();
}

# 終了かどうか
sub gameOver {
    # 時間切れ
    if($H2::finishTurn) {
	if ($H2::islandTurn >= $H2::finishTurn) {
	    return maxScoreCamp();
	}
    }
    # コールド
    my($i);
    for ($i = 0; $i < $H2::campNumber; $i++) {
	if ($H2::camp[$i]->{'occupation'} >= $H2::finishOccupation) {
	    return $i;
	}
    }
    return -1;
}

sub campOccupy {
    my($i);
    my($totalScore) = 0;

    for ($i = 0; $i < $H2::campNumber; $i++) {
	$totalScore += $H2::camp[$i]->{'score'};
    }
    for ($i = 0; $i < $H2::campNumber; $i++) {
	if ($totalScore != 0) {
	    $H2::camp[$i]->{'occupation'} = int($H2::camp[$i]->{'score'} / $totalScore * 100);
	}
	else {
	    $H2::camp[$i]->{'occupation'} = int(100 / $H2::campNumber);
	}
    }
    return;
}

# ディレクトリ消し
sub myrmtree {
    my($dn) = @_;
    opendir(DIN, "$dn/");
    my($fileName);
    while($fileName = readdir(DIN)) {
	unlink("$dn/$fileName");
    } 
    closedir(DIN);
    rmdir($dn);
}

# 収入、消費フェイズ
sub income {
    my($island) = @_;
    my($pop, $farm, $factory, $mountain) = 
	(      
	 $island->{'pop'},
	 $island->{'farm'} * 10,
	 $island->{'factory'},
	 $island->{'mountain'}
	 );
    # 古い資金，食料をメモる
    my($oldmoney, $oldfood, $gnp) = ($island->{'money'}, $island->{'food'}, 0);

    # 収入
    if($pop > $farm) {
	# 農業だけじゃ手が余る場合
	$island->{'food'} += $farm; # 農場フル稼働
	$island->{'money'} +=
	    min(int(($pop - $farm) / 10),
		 $factory + $mountain);
    } else {
	# 農業だけで手一杯の場合
	$island->{'food'} += $pop; # 全員野良仕事
    }

    # 食料消費
    $island->{'food'} = int(($island->{'food'}) - ($pop * $H2::eatenFood));

    # 陣営GNP
    $gnp = int($island->{'money'} - $oldmoney + ($island->{'food'} - $oldfood)/10);
    ${H2::camp[$H2::idToCampNumber{$island->{'score'}}]->{'ext'}[2]} += $gnp;
}


# コマンドフェイズ
sub doCommand {
    my($island) = @_;

    # コマンド取り出し
    my($comArray, $command);
    $comArray = $island->{'command'};
    $command = $comArray->[0]; # 最初のを取り出し
    slideFront($comArray, 0); # 以降を詰める

    # 各要素の取り出し
    my($kind, $target, $x, $y, $arg) = 
	(
	 $command->{'kind'},
	 $command->{'target'},
	 $command->{'x'},
	 $command->{'y'},
	 $command->{'arg'}
	 );

    # 導出値
    my($name) = $island->{'name'};
    my($id) = $island->{'id'};
    my($land) = $island->{'land'};
    my($landValue) = $island->{'landValue'};
    my($landKind) = $land->[$x][$y];
    my($lv) = $landValue->[$x][$y];
    my($cost) = $H2::comCost[$kind];
    my($comName) = $H2::comName[$kind];
    my($point) = "($x, $y)";
    my($landName) = landName($landKind, $lv);
    my($camp) = $H2::camp[$H2::idToCampNumber{$island->{'score'}}];

    if($kind == $H2::comDoNothing) {
	# 資金繰り
	logDoNothing($id, $name, $comName);
	$island->{'money'} += $cost;
	$island->{'absent'} ++;

	# 陣営預かり判定
	if ($island->{'absent'} > $H2::preGiveupTurn) {
		# passwardを陣営パスワードに変更（毎ターン）
		$island->{'password'} = encode($camp->{'passward'});
		$island->{'comment'} = 'この島は陣営預かりになりました。';
	}
	
	# 自動放棄
	if($island->{'absent'} >= $H2::giveupTurn) {
	    $comArray->[0] = {
		'kind' => $H2::comGiveup,
		'target' => 0,
		'x' => 0,
		'y' => 0,
		'arg' => 0
	    }
	}
	return 1;
    }

    $island->{'absent'} = 0;

    # コストチェック
    if($cost > 0) {
	# 金の場合
	if($island->{'money'} < $cost) {
	    logNoMoney($id, $name, $comName);
	    return 0;
	}
    } elsif($cost < 0) {
	# 食料の場合
	if($island->{'food'} < (-$cost)) {
	    logNoFood($id, $name, $comName);
	    return 0;
	}
    }

    # コマンドで分岐
    if(($kind == $H2::comPrepare) ||
       ($kind == $H2::comPrepare2)) {
	# 整地、地ならし
	if(($landKind == $H2::landSea) || 
	   ($landKind == $H2::landSbase) ||
	   ($landKind == $H2::landOil) ||
	   ($landKind == $H2::landMountain) ||
	   ($landKind == $H2::landMonster)) {
	    # 海、海底基地、油田、山、怪獣は整地できない
	    logLandFail($id, $name, $comName, $landName, $point);
	    return 0;
	}

	# 目的の場所を平地にする
	$land->[$x][$y] = $H2::landPlains;
	$landValue->[$x][$y] = 0;
	logLandSuc($id, $name, '整地', $point);

	# 金を差し引く
	$island->{'money'} -= $cost;

	if($kind == $H2::comPrepare2) {
	    # 地ならし
	    $island->{'prepare2'}++;
	    
	    # ターン消費せず
	    return 0;
	} else {
	    # 整地なら、埋蔵金の可能性あり
	    if(random(1000) < $H2::disMaizo) {
		my($v) = 100 + random(901);
		$island->{'money'} += $v;
		logMaizo($id, $name, $comName, $v);
	    }
	    return 1;
	}
    } elsif($kind == $H2::comReclaim) {
	# 埋め立て
	if(($landKind != $H2::landSea) &&
	   ($landKind != $H2::landOil) &&
	   ($landKind != $H2::landSbase)) {
	    # 海、海底基地、油田しか埋め立てできない
	    logLandFail($id, $name, $comName, $landName, $point);
	    return 0;
	}

	# 周りに陸があるかチェック
	my($seaCount) = countAround($land, $x, $y, $H2::landSea, 7);
        if($seaCount == 7) {
	    # 全部海だから埋め立て不能
	    logNoLandAround($id, $name, $comName, $point);
	    return 0;
	}

	if($lv == 1) {
	    # 浅瀬の場合
	    # 目的の場所を荒地にする
	    $land->[$x][$y] = $H2::landWaste;
	    $landValue->[$x][$y] = 0;
	    logLandSuc($id, $name, $comName, $point);
	    $island->{'area'}++;

	    if($seaCount <= 4) {
		# 周りの海が3ヘックス以内なので、浅瀬にする
		my($i, $sx, $sy);

		for($i = 1; $i < 7; $i++) {
		    $sx = $x + $ax[$i];
		    $sy = $y + $ay[$i];

		    # 行による位置調整
		    if((($sy % 2) == 0) && (($y % 2) == 1)) {
			$sx--;
		    }

		    if(($sx < 0) || ($sx >= $H2::islandSize) ||
		       ($sy < 0) || ($sy >= $H2::islandSize)) {
		    } else {
			# 範囲内の場合
			if($land->[$sx][$sy] == $H2::landSea) {
			    $landValue->[$sx][$sy] = 1;
			}
		    }
		}
	    }
	} else {
	    # 海なら、目的の場所を浅瀬にする
	    $landValue->[$x][$y] = 1;
	    logLandSuc($id, $name, $comName, $point);
	}
	
	# 金を差し引く
	$island->{'money'} -= $cost;
	return 1;
    } elsif($kind == $H2::comDestroy) {
	# 掘削
	if(($landKind == $H2::landSbase) ||
	   ($landKind == $H2::landOil) ||
	   ($landKind == $H2::landMonster)) {
	    # 海底基地、油田、怪獣は掘削できない
	    logLandFail($id, $name, $comName, $landName, $point);
	    return 0;
	}

	if(($landKind == $H2::landSea) && ($lv == 0)) {

	    if ($H2::islandTurn <= $H2::armisticeTurn) {
	        # 開発期間中は油田禁止
	        logNotAvail($id, $name, $comName);
	        return 0;
	    }

	    # 海なら、油田探し
	    # 投資額決定
	    if($arg == 0) { $arg = 1; }
	    my($value, $str, $p);
	    $value = min($arg * ($cost), $island->{'money'});
	    $str = "$value$H2::unitMoney";
	    $p = int($value / $cost);
	    $island->{'money'} -= $value;

	    # 見つかるか判定
	    if($p > random(100)) {
		# 油田見つかる
		logOilFound($id, $name, $point, $comName, $str);
		$land->[$x][$y] = $H2::landOil;
		$landValue->[$x][$y] = 0;
	    } else {
		# 無駄撃ちに終わる
		logOilFail($id, $name, $point, $comName, $str);
	    }
	    return 1;
	}

	# 目的の場所を海にする。山なら荒地に。浅瀬なら海に。
	if($landKind == $H2::landMountain) {
	    $land->[$x][$y] = $H2::landWaste;
	    $landValue->[$x][$y] = 0;
	} elsif($landKind == $H2::landSea) {
	    $landValue->[$x][$y] = 0;
	} else {
	    $land->[$x][$y] = $H2::landSea;
	    $landValue->[$x][$y] = 1;
	    $island->{'area'}--;
	}
	logLandSuc($id, $name, $comName, $point);

	# 金を差し引く
	$island->{'money'} -= $cost;
	return 1;
    } elsif($kind == $H2::comSellTree) {
	# 伐採
	if($landKind != $H2::landForest) {
	    # 森以外は伐採できない
	    logLandFail($id, $name, $comName, $landName, $point);
	    return 0;
	}

	# 目的の場所を平地にする
	$land->[$x][$y] = $H2::landPlains;
	$landValue->[$x][$y] = 0;
	logLandSuc($id, $name, $comName, $point);

	# 売却金を得る
	$island->{'money'} += $H2::treeValue * $lv;
	return 0;
    } elsif(($kind == $H2::comPlant) ||
	    ($kind == $H2::comFarm) ||
	    ($kind == $H2::comFactory) ||
	    ($kind == $H2::comBase) ||
	    ($kind == $H2::comMonument) ||
	    ($kind == $H2::comHaribote) ||
	    ($kind == $H2::comDbase)) {

	# 地上建設系
	if(!
	   (($landKind == $H2::landPlains) ||
	    ($landKind == $H2::landTown) ||
	    (($landKind == $H2::landMonument) && ($kind == $H2::comMonument)) ||
	    (($landKind == $H2::landFarm) && ($kind == $H2::comFarm)) ||
	    (($landKind == $H2::landFactory) && ($kind == $H2::comFactory)) ||
	    (($landKind == $H2::landDefence) && ($kind == $H2::comDbase)))) {
	    # 不適当な地形
	    logLandFail($id, $name, $comName, $landName, $point);
	    return 0;
	}

	# 種類で分岐
	if($kind == $H2::comPlant) {
	    # 目的の場所を森にする。
	    $land->[$x][$y] = $H2::landForest;
	    $landValue->[$x][$y] = 1; # 木は最低単位
	    logPBSuc($id, $name, $comName, $point);
	} elsif($kind == $H2::comBase) {
	    # 目的の場所をミサイル基地にする。
	    $land->[$x][$y] = $H2::landBase;
	    $landValue->[$x][$y] = 0; # 経験値0
	    logPBSuc($id, $name, $comName, $point);
	} elsif($kind == $H2::comHaribote) {
	    # 目的の場所をハリボテにする
	    $land->[$x][$y] = $H2::landHaribote;
	    $landValue->[$x][$y] = 0;
	    logHariSuc($id, $name, $comName, $H2::comName[$H2::comDbase], $point);
	} elsif($kind == $H2::comFarm) {
	    # 農場
	    if($landKind == $H2::landFarm) {
		# すでに農場の場合
		$landValue->[$x][$y] += 2; # 規模 + 2000人
		if($landValue->[$x][$y] > 50) {
		    $landValue->[$x][$y] = 50; # 最大 50000人
		}
	    } else {
		# 目的の場所を農場に
		$land->[$x][$y] = $H2::landFarm;
		$landValue->[$x][$y] = 10; # 規模 = 10000人
	    }
	    logLandSuc($id, $name, $comName, $point);
	} elsif($kind == $H2::comFactory) {
	    # 工場
	    if($landKind == $H2::landFactory) {
		# すでに工場の場合
		$landValue->[$x][$y] += 10; # 規模 + 10000人
		if($landValue->[$x][$y] > 100) {
		    $landValue->[$x][$y] = 100; # 最大 100000人
		}
	    } else {
		# 目的の場所を工場に
		$land->[$x][$y] = $H2::landFactory;
		$landValue->[$x][$y] = 30; # 規模 = 10000人
	    }
	    logLandSuc($id, $name, $comName, $point);
	} elsif($kind == $H2::comDbase) {
	    # 防衛施設
	    if($landKind == $H2::landDefence) {
		# すでに防衛施設の場合
		$landValue->[$x][$y] = 1; # 自爆装置セット
		logBombSet($id, $name, $landName, $point);
	    } else {
		# 目的の場所を防衛施設に
		$land->[$x][$y] = $H2::landDefence;
		$landValue->[$x][$y] = 0;
		if ($H2::dBaseHide) { # 防衛施設を森に偽装する?
		    logPBSuc($id, $name, $comName, $point);
		} else {
		    logLandSuc($id, $name, $comName, $point);
		}
	    }
	} elsif($kind == $H2::comMonument) {
	    # 記念碑
	    if($landKind == $H2::landMonument) {
		# すでに記念碑の場合
		# ターゲット取得
		my($tn) = $H2::idToNumber{$target};
		if($tn eq '') {
		    # ターゲットがすでにない
		    # 何も言わずに中止
		    return 0;
		}

		my($tIsland) = $H2::islands[$tn];

		if ($H2::islandTurn <= $H2::armisticeTurn || $tIsland->{'score'} == $island->{'score'}) {
		    # 攻撃が許可されていない
		    logNotAvail($id, $name, $comName);
		    return 0;
		}
		
		$tIsland->{'bigmissile'}++;
		$island->{'ext'}[1] += $cost; #貢献度
		$tIsland->{'ext'}[1] += $cost; #貢献度

		# その場所は荒地に
		$land->[$x][$y] = $H2::landWaste;
		$landValue->[$x][$y] = 0;
		logMonFly($id, $name, $landName, $point);
	    } else {
		# 目的の場所を記念碑に
		$land->[$x][$y] = $H2::landMonument;
		if($arg >= $H2::monumentNumber) {
		    $arg = 0;
		}
		$landValue->[$x][$y] = $arg;
		logLandSuc($id, $name, $comName, $point);
	    }
	}

	# 金を差し引く
	$island->{'money'} -= $cost;
	return 1;
    } elsif($kind == $H2::comMountain) {
	# 採掘場
	if($landKind != $H2::landMountain) {
	    # 山以外には作れない
	    logLandFail($id, $name, $comName, $landName, $point);
	    return 0;
	}

	$landValue->[$x][$y] += 5; # 規模 + 5000人
	if($landValue->[$x][$y] > 200) {
	    $landValue->[$x][$y] = 200; # 最大 200000人
	}
	logLandSuc($id, $name, $comName, $point);

	# 金を差し引く
	$island->{'money'} -= $cost;
	return 1;
    } elsif($kind == $H2::comSbase) {
	# 海底基地
	if(($landKind != $H2::landSea) || ($lv != 0)){
	    # 海以外には作れない
	    logLandFail($id, $name, $comName, $landName, $point);
	    return 0;
	}

	$land->[$x][$y] = $H2::landSbase;
	$landValue->[$x][$y] = 0; # 経験値0
	logLandSuc($id, $name, $comName, '(?, ?)');

	# 金を差し引く
	$island->{'money'} -= $cost;
	return 1;
    } elsif(($kind == $H2::comMissileNM) ||
	    ($kind == $H2::comMissilePP) ||
	    ($kind == $H2::comMissileST) ||
	    ($kind == $H2::comMissileLD)) {
	# ミサイル系
	# ターゲット取得
	my($tn) = $H2::idToNumber{$target};
	if($tn eq '') {
	    # ターゲットがすでにない
	    logMsNoTarget($id, $name, $comName);
	    return 0;
	}

	if ($H2::islandTurn <= $H2::armisticeTurn) {
	    # 攻撃が許可されていない
	    logNotAvail($id, $name, $comName);
	    return 0;
	}
	
	my($flag) = 0;
	if($arg == 0) {
	    # 0の場合は撃てるだけ
	    $arg = 10000;
	}

	# 事前準備
	my($tIsland) = $H2::islands[$tn];
	my($tName) = $tIsland->{'name'};
	my($tLand) = $tIsland->{'land'};
	my($tLandValue) = $tIsland->{'landValue'};
	my($tCamp) = $H2::camp[$H2::idToCampNumber{$tIsland->{'score'}}];
	my($tx, $ty, $err);

	# 難民の数
	my($boat) = 0;

	# 誤差
	if($kind == $H2::comMissilePP) {
	    $err = 7;
	} else {
	    $err = 19;
	}

	# 金が尽きるか指定数に足りるか基地全部が撃つまでループ
	my($bx, $by, $count) = (0,0,0);
	while(($arg > 0) &&
	      ($island->{'money'} >= $cost)) {
	    # 基地を見つけるまでループ
	    while($count < $H2::pointNumber) {
		$bx = $H2::rpx[$count];
		$by = $H2::rpy[$count];
		if(($land->[$bx][$by] == $H2::landBase) ||
		   ($land->[$bx][$by] == $H2::landSbase)) {
		    last;
		}
		$count++;
	    }
	    if($count >= $H2::pointNumber) {
		# 見つからなかったらそこまで
		last;
	    }
	    # 最低一つ基地があったので、flagを立てる
	    $flag = 1;	   

	    # 基地のレベルを算出
	    my($level) = expToLevel($land->[$bx][$by], $landValue->[$bx][$by]);
	    # 基地内でループ
	    while(($level > 0) &&
		  ($arg > 0) &&
		  ($island->{'money'} > $cost)) {
		# 撃ったのが確定なので、各値を消耗させる
		$level--;
		$arg--;
		$island->{'money'} -= $cost;

		if($kind != $H2::comMissileST) {
		    $island->{'ext'}[1] += $cost; # 貢献度
		    $island->{'ext'}[6]++; # 発射したミサイルの数
		    $camp->{'ext'}[0]++;
		}
		if($tIsland->{'score'} == $island->{'score'}) {
		    # 味方に撃たれた場合貢献度マイナス
		    $tIsland->{'ext'}[1] -= $cost; # 貢献度
		} else {    
		    # 敵に撃たれた場合貢献度プラス
		    $tIsland->{'ext'}[1] += $cost; # 貢献度
		    $tIsland->{'ext'}[5]++; # 受けたミサイルの数
		}
		$tCamp->{'ext'}[1]++;
		
		# 着弾点算出
		my($r) = random($err);
		$tx = $x + $ax[$r];
		$ty = $y + $ay[$r];
		if((($ty % 2) == 0) && (($y % 2) == 1)) {
		    $tx--;
		}

		# 着弾点範囲内外チェック
		if(($tx < 0) || ($tx >= $H2::islandSize) ||
		   ($ty < 0) || ($ty >= $H2::islandSize)) {
		    # 範囲外
		    if($kind == $H2::comMissileST) {
			# ステルス
			logMsOutS($id, $target, $name, $tName,
				   $comName, $point);
		    } else {
			# 通常系
			logMsOut($id, $target, $name, $tName,
				  $comName, $point);
		    }
		    next;
		}

		# 着弾点の地形等算出
		my($tL) = $tLand->[$tx][$ty];
		my($tLv) = $tLandValue->[$tx][$ty];
		my($tLname) = landName($tL, $tLv);
		my($tPoint) = "($tx, $ty)";

		# 防衛施設判定
		my($defence) = 0;
		if($H2::defenceHex[$id][$tx][$ty] == 1) {
		    $defence = 1;
		} elsif($H2::defenceHex[$id][$tx][$ty] == -1) {
		    $defence = 0;
		} else {
		    if($tL == $H2::landDefence) {
			# 防衛施設に命中
			# フラグをクリア
			my($i, $count, $sx, $sy);
			for($i = 0; $i < 19; $i++) {
			    $sx = $tx + $ax[$i];
			    $sy = $ty + $ay[$i];

			    # 行による位置調整
			    if((($sy % 2) == 0) && (($ty % 2) == 1)) {
				$sx--;
			    }

			    if(($sx < 0) || ($sx >= $H2::islandSize) ||
			       ($sy < 0) || ($sy >= $H2::islandSize)) {
				# 範囲外の場合何もしない
			    } else {
				# 範囲内の場合
				$H2::defenceHex[$id][$sx][$sy] = 0;
			    }
			}
			if($kind != $H2::comMissileST) {
			    $island->{'ext'}[2]++; # 破壊した防衛施設の数
			}
		    } elsif(countAround($tLand, $tx, $ty, $H2::landDefence, 19)) {
			$H2::defenceHex[$id][$tx][$ty] = 1;
			$defence = 1;
		    } else {
			$H2::defenceHex[$id][$tx][$ty] = -1;
			$defence = 0;
		    }
		}
		
		if($defence == 1) {
		    # 空中爆破
		    if($kind == $H2::comMissileST) {
			# ステルス
			logMsCaughtS($id, $target, $name, $tName,
				      $comName, $point, $tPoint);
		    } else {
			# 通常系
			logMsCaught($id, $target, $name, $tName,
				     $comName, $point, $tPoint);
		    }
		    $tIsland->{'ext'}[7]++; # 防衛施設で弾いたミサイルの数
		    next;
		}

		# 「効果なし」hexを最初に判定
		if((($tL == $H2::landSea) && ($tLv == 0))|| # 深い海
		   ((($tL == $H2::landSea) ||   # 海または・・・
		     ($tL == $H2::landSbase) ||   # 海底基地または・・・
		     ($tL == $H2::landMountain)) # 山で・・・
		    && ($kind != $H2::comMissileLD))) { # 陸破弾以外
		    # 海底基地の場合、海のフリ
		    if($tL == $H2::landSbase) {
			$tL = $H2::landSea;
		    }
		    $tLname = landName($tL, $tLv);

		    # 無効化
		    if($kind == $H2::comMissileST) {
			# ステルス
			logMsNoDamageS($id, $target, $name, $tName,
					$comName, $tLname, $point, $tPoint);
		    } else {
			# 通常系
			logMsNoDamage($id, $target, $name, $tName,
				       $comName, $tLname, $point, $tPoint);
		    }
		    next;
		}

		# 弾の種類で分岐
		if($kind == $H2::comMissileLD) {
		    # 陸地破壊弾
		    if($tL == $H2::landMountain) {
			# 山(荒地になる)
			logMsLDMountain($id, $target, $name, $tName,
					 $comName, $tLname, $point, $tPoint);
			# 荒地になる
			$tLand->[$tx][$ty] = $H2::landWaste;
			$tLandValue->[$tx][$ty] = 0;
			next;

		    } elsif($tL == $H2::landSbase) {
			# 海底基地
			logMsLDSbase($id, $target, $name, $tName,
				      $comName, $tLname, $point, $tPoint);
		    } elsif($tL == $H2::landMonster) {
			# 怪獣
			logMsLDMonster($id, $target, $name, $tName,
					$comName, $tLname, $point, $tPoint);
		    } elsif($tL == $H2::landSea) {
			# 浅瀬
			logMsLDSea1($id, $target, $name, $tName,
				    $comName, $tLname, $point, $tPoint);
		    } else {
			# その他
			logMsLDLand($id, $target, $name, $tName,
				     $comName, $tLname, $point, $tPoint);
		    }
		    
		    # 経験値
		    if($tL == $H2::landTown) {
			if(($land->[$bx][$by] == $H2::landBase) ||
			   ($land->[$bx][$by] == $H2::landSbase)) {
			    # まだ基地の場合のみ
			    $landValue->[$bx][$by] += int($tLv / 20);
			    if($landValue->[$bx][$by] > $H2::maxExpPoint) {
				$landValue->[$bx][$by] = $H2::maxExpPoint;
			    }
			}
		    }

		    # 浅瀬になる
		    $tLand->[$tx][$ty] = $H2::landSea;
		    $tIsland->{'area'}--;
		    $tLandValue->[$tx][$ty] = 1;

		    # でも油田、浅瀬、海底基地だったら海
		    if(($tL == $H2::landOil) ||
			($tL == $H2::landSea) ||
		       ($tL == $H2::landSbase)) {
			$tLandValue->[$tx][$ty] = 0;
		    }
		} else {
		    # その他ミサイル
		    if($tL == $H2::landWaste) {
			# 荒地(被害なし)
			if($kind == $H2::comMissileST) {
			    # ステルス
			    logMsWasteS($id, $target, $name, $tName,
					 $comName, $tLname, $point, $tPoint);
			} else {
			    # 通常
			    logMsWaste($id, $target, $name, $tName,
					$comName, $tLname, $point, $tPoint);
			}
		    } elsif($tL == $H2::landMonster) {
			# 怪獣
			my($mKind, $mName, $mHp) = monsterSpec($tLv);
			my($special) = $H2::monsterSpecial[$mKind];

			# 硬化中?
			if((($special == 3) && (($H2::islandTurn % 2) == 1)) ||
			   (($special == 4) && (($H2::islandTurn % 2) == 0))) {
			    # 硬化中
			    if($kind == $H2::comMissileST) {
				# ステルス
				logMsMonNoDamageS($id, $target, $name, $tName,
					     $comName, $mName, $point,
					     $tPoint);
			    } else {
				# 通常弾
				logMsMonNoDamage($id, $target, $name, $tName,
					     $comName, $mName, $point,
					     $tPoint);
			    }
			    next;
			} else {
			    # 硬化中じゃない
			    if($mHp == 1) {
				# 怪獣しとめた
				if(($land->[$bx][$by] == $H2::landBase) ||
				   ($land->[$bx][$by] == $H2::landSbase)) {
				    # 経験値
				    $landValue->[$bx][$by] += $H2::monsterExp[$mKind];
				    if($landValue->[$bx][$by] > $H2::maxExpPoint) {
					$landValue->[$bx][$by] = $H2::maxExpPoint;
				    }
				}

				if($kind == $H2::comMissileST) {
				    # ステルス
				    logMsMonKillS($id, $target, $name, $tName,
						  $comName, $mName, $point,
						  $tPoint);
				} else {
				    # 通常
				    logMsMonKill($id, $target, $name, $tName,
						 $comName, $mName, $point,
						 $tPoint);
				}

				# 収入
				my($value) = $H2::monsterValue[$mKind];
				if($value > 0) {
				    $tIsland->{'money'} += $value;
				    logMsMonMoney($target, $mName, $value);
				}
				# 賞関係
				my($prize) = $island->{'prize'};
				$prize =~ /([0-9]*),([0-9]*),(.*)/;
				my($flags) = $1;
				my($monsters) = $2;
				my($turns) = $3;
				my($v) = 2 ** $mKind;
				$monsters |= $v;
				$island->{'prize'} = "$flags,$monsters,$turns";
			    } else {
				# 怪獣生きてる
				if($kind == $H2::comMissileST) {
				    # ステルス
				    logMsMonsterS($id, $target, $name, $tName,
						  $comName, $mName, $point,
						  $tPoint);
				} else {
				    # 通常
				    logMsMonster($id, $target, $name, $tName,
						 $comName, $mName, $point,
						 $tPoint);
				}
				# HPが1減る
				$tLandValue->[$tx][$ty]--;
				next;
			    }

			}
		    } else {
			# 通常地形
			if($kind == $H2::comMissileST) {
			    # ステルス
			    logMsNormalS($id, $target, $name, $tName,
					   $comName, $tLname, $point,
					   $tPoint);
			} else {
			    # 通常
			    logMsNormal($id, $target, $name, $tName,
					 $comName, $tLname, $point,
					 $tPoint);
			    if ($tL == $H2::landBase) {
				$island->{'ext'}[3]++; # 撃破したミサイル基地の数
			    }
			}
		    }
		    # 経験値
		    if($tL == $H2::landTown) {
			if(($land->[$bx][$by] == $H2::landBase) ||
			    ($land->[$bx][$by] == $H2::landSbase)) {
			    $landValue->[$bx][$by] += int($tLv / 20);
			    $boat += $tLv; # 通常ミサイルなので難民にプラス
			    if($landValue->[$bx][$by] > $H2::maxExpPoint) {
				$landValue->[$bx][$by] = $H2::maxExpPoint;
			    }
			}
		    }
		    
                    # 荒地になる
		    $tLand->[$tx][$ty] = $H2::landWaste;
		    $tLandValue->[$tx][$ty] = 1; # 着弾点

		    # でも油田だったら海
		    if($tL == $H2::landOil) {
			$tLand->[$tx][$ty] = $H2::landSea;
			$tLandValue->[$tx][$ty] = 0;
		    }
		} 
	    }

	    # カウント増やしとく
	    $count++;
	}


	if($flag == 0) {
	    # 基地が一つも無かった場合
	    logMsNoBase($id, $name, $comName);
	    return 0;
	}

	# 難民判定
	$boat = int($boat / 2);
	if(($boat > 0) && ($id != $target) && ($kind != $H2::comMissileST)) {
	    # 難民漂着
	    my($achive); # 到達難民
	    my($i);
	    
	    for($i = 0; ($i < $H2::pointNumber && $boat > 0); $i++) {
		$bx = $H2::rpx[$i];
		$by = $H2::rpy[$i];
		if($land->[$bx][$by] == $H2::landTown) {
		    # 町の場合
		    my($lv) = $landValue->[$bx][$by];
		    if($boat > 50) {
			$lv += 50;
			$boat -= 50;
			$achive += 50;
		    } else {
			$lv += $boat;
			$achive += $boat;
			$boat = 0;
		    }
		    if($lv > 200) {
			$boat += ($lv - 200);
			$achive -= ($lv - 200);
			$lv = 200;
		    }
		    $landValue->[$bx][$by] = $lv;
		} elsif($land->[$bx][$by] == $H2::landPlains) {
		    # 平地の場合
		    $land->[$bx][$by] = $H2::landTown;;
		    if($boat > 10) {
			$landValue->[$bx][$by] = 5;
			$boat -= 10;
			$achive += 10;
		    } elsif($boat > 5) {
			$landValue->[$bx][$by] = $boat - 5;
			$achive += $boat;
			$boat = 0;
		    }
		}
		if($boat <= 0) {
		    last;
		}
	    }
	    if($achive > 0) {
		# 少しでも到着した場合、ログを吐く
		logMsBoatPeople($id, $name, $achive);
		$island->{'ext'}[4] += int($achive); # 救出した難民の合計人口
	    }
	}
	return 1;
    } elsif($kind == $H2::comSendMonster) {
	# 怪獣派遣
	# ターゲット取得
	my($tn) = $H2::idToNumber{$target};
	my($tIsland) = $H2::islands[$tn];
	my($tName) = $tIsland->{'name'};

	if($tn eq '') {
	    # ターゲットがすでにない
	    logMsNoTarget($id, $name, $comName);
	    return 0;
	}

	if ($H2::islandTurn <= $H2::armisticeTurn || $tIsland->{'score'} == $island->{'score'}) {
	    # 攻撃が許可されていない
	    logNotAvail($id, $name, $comName);
	    return 0;
	}

	# メッセージ
	logMonsSend($id, $target, $name, $tName);
	$tIsland->{'monstersend'}++;

	$island->{'money'} -= $cost;
	$island->{'ext'}[1] += $cost; # 貢献度
	$tIsland->{'ext'}[1] += $cost; # 貢献度
	return 1;

    } elsif($kind == $H2::comSell) {
	# 輸出量決定
	if($arg == 0) { $arg = 1; }
	my($value) = min($arg * (-$cost), $island->{'food'});

	# 輸出ログ
	logSell($id, $name, $comName, $value);
	$island->{'food'} -=  $value;
	$island->{'money'} += ($value / 10);
	return 0;
    } elsif(($kind == $H2::comFood) ||
	    ($kind == $H2::comMoney)) {
	# 援助系
	# ターゲット取得
	my($tn) = $H2::idToNumber{$target};
	my($tIsland) = $H2::islands[$tn];
	my($tName) = $tIsland->{'name'};

	if ($H2::campAidOnly == 0 || $island->{'score'} == $tIsland->{'score'}) {
	    # 同じ陣営のみ許可される
	    # 援助量決定
	    if($arg == 0) { $arg = 1; }
	    my($value, $str);
	    if($cost < 0) {
		$value = min($arg * (-$cost), $island->{'food'});
		$str = "$value$H2::unitFood";
	    } else {
	        $value = min($arg * ($cost), $island->{'money'});
	        $str = "$value$H2::unitMoney";
	    }

	    # 援助ログ
	    logAid($id, $target, $name, $tName, $comName, $str);

	    if($cost < 0) {
	        $island->{'food'} -= $value;
	        $tIsland->{'food'} += $value;
	        $island->{'ext'}[1] += int($value/10); # 貢献度
	        $tIsland->{'ext'}[1] -= int($value/10); # 貢献度        
	    } else {
	        $island->{'money'} -= $value;
	        $tIsland->{'money'} += $value;
	        $island->{'ext'}[1] += $value; # 貢献度
	        $tIsland->{'ext'}[1] -= $value; # 貢献度   
	    }
	} else { 
	    # 援助が許可されていない
	    logAidFail($id, $target, $name, $tName, $comName);
	}
	return 0;
    } elsif($kind == $H2::comPropaganda) {
	# 誘致活動
	logPropaganda($id, $name, $comName);
	$island->{'propaganda'} = 1;
	$island->{'money'} -= $cost;
	return 1;
    } elsif($kind == $H2::comGiveup) {
	# 放棄
	logGiveup($id, $name);
	$island->{'dead'} = 1;
	unlink("island.$id");
	return 1;
    }

    return 1;
}


# 成長および単ヘックス災害
sub doEachHex {
    my($island) = @_;
    my(@monsterMove);

    # 導出値
    my($name) = $island->{'name'};
    my($id) = $island->{'id'};
    my($land) = $island->{'land'};
    my($landValue) = $island->{'landValue'};

    # 増える人口のタネ値
    my($addpop)  = 10;  # 村、町
    my($addpop2) = 0; # 都市
    if($island->{'food'} < 0) {
	# 食料不足
	$addpop = -30;
    } elsif($island->{'propaganda'} == 1) {
	# 誘致活動中
	$addpop = 30;
	$addpop2 = 3;
    }

    # ループ
    my($x, $y, $i);
    for($i = 0; $i < $H2::pointNumber; $i++) {
	$x = $H2::rpx[$i];
	$y = $H2::rpy[$i];
	my($landKind) = $land->[$x][$y];
	my($lv) = $landValue->[$x][$y];

	if($landKind == $H2::landTown) {
	    # 町系
	    if($addpop < 0) {
		# 不足
		$lv -= (random(-$addpop) + 1);
		if($lv <= 0) {
		    # 平地に戻す
		    $land->[$x][$y] = $H2::landPlains;
		    $landValue->[$x][$y] = 0;
		    next;
		}
	    } else {
		# 成長
		if($lv < 100) {
		    $lv += random($addpop) + 1;
		    if($lv > 100) {
			$lv = 100;
		    }
		} else {
		    # 都市になると成長遅い
		    if($addpop2 > 0) {
			$lv += random($addpop2) + 1;
		    }
		}
	    }
	    if($lv > 200) {
		$lv = 200;
	    }
	    $landValue->[$x][$y] = $lv;
	} elsif($landKind == $H2::landPlains) {
	    # 平地
	    if(random(5) == 0) {
		# 周りに農場、町があれば、ここも町になる
	        if(countGrow($land, $landValue, $x, $y)){
		    $land->[$x][$y] = $H2::landTown;
		    $landValue->[$x][$y] = 1;
		}
	    }
	} elsif($landKind == $H2::landForest) {
	    # 森
	    if($lv < 200) {
		# 木を増やす
		$landValue->[$x][$y]++;
	    }
	} elsif($landKind == $H2::landDefence) {
	    if($lv == 1) {
		# 防衛施設自爆
		my($lName) = &landName($landKind, $lv);
		logBombFire($id, $name, $lName, "($x, $y)");

		# 広域被害ルーチン
		wideDamage($id, $name, $land, $landValue, $x, $y);
	    }
	} elsif($landKind == $H2::landOil) {
	    # 海底油田
	    my($value, $str, $lName);
	    $lName = landName($landKind, $lv);
	    $value = $H2::oilMoney;
	    $island->{'money'} += $value;
	    $str = "$value$H2::unitMoney";

	    # 収入ログ
	    logOilMoney($id, $name, $lName, "($x, $y)", $str);

	    # 枯渇判定
	    if(random(1000) < $H2::oilRatio) {
		# 枯渇
		logOilEnd($id, $name, $lName, "($x, $y)");
		$land->[$x][$y] = $H2::landSea;
		$landValue->[$x][$y] = 0;
	    }

	} elsif($landKind == $H2::landMonster) {
	    # 怪獣
	    if($monsterMove[$x][$y] == 2) {
		# すでに動いた後
		next;
	    }

	    # 各要素の取り出し
	    my($mKind, $mName, $mHp) = monsterSpec($landValue->[$x][$y]);
	    my($special) = $H2::monsterSpecial[$mKind];

	    # 硬化中?
	    if((($special == 3) && (($H2::islandTurn % 2) == 1)) ||
	       (($special == 4) && (($H2::islandTurn % 2) == 0))) {
		# 硬化中
		next;
	    }

	    # 動く方向を決定
	    my($d, $sx, $sy);
	    my($i);
	    for($i = 0; $i < 3; $i++) {
		$d = random(6) + 1;
		$sx = $x + $ax[$d];
		$sy = $y + $ay[$d];

		# 行による位置調整
		if((($sy % 2) == 0) && (($y % 2) == 1)) {
		    $sx--;
		}

		# 範囲外判定
		if(($sx < 0) || ($sx >= $H2::islandSize) ||
		   ($sy < 0) || ($sy >= $H2::islandSize)) {
		    next;
		}

		# 海、海基、油田、怪獣、山、記念碑以外
		if(($land->[$sx][$sy] != $H2::landSea) &&
		   ($land->[$sx][$sy] != $H2::landSbase) &&
		   ($land->[$sx][$sy] != $H2::landOil) &&
		   ($land->[$sx][$sy] != $H2::landMountain) &&
		   ($land->[$sx][$sy] != $H2::landMonument) &&
		   ($land->[$sx][$sy] != $H2::landMonster)) {
		    last;
		}
	    }

	    if($i == 3) {
		# 動かなかった
		next;
	    }

	    # 動いた先の地形によりメッセージ
	    my($l) = $land->[$sx][$sy];
	    my($lv) = $landValue->[$sx][$sy];
	    my($lName) = landName($l, $lv);
	    my($point) = "($sx, $sy)";

	    # 移動
	    $land->[$sx][$sy] = $land->[$x][$y];
	    $landValue->[$sx][$sy] = $landValue->[$x][$y];

	    # もと居た位置を荒地に
	    $land->[$x][$y] = $H2::landWaste;
	    $landValue->[$x][$y] = 0;

	    # 移動済みフラグ
	    if($H2::monsterSpecial[$mKind] == 2) {
		# 移動済みフラグは立てない
	    } elsif($H2::monsterSpecial[$mKind] == 1) {
		# 速い怪獣
		$monsterMove[$sx][$sy] = $monsterMove[$x][$y] + 1;
	    } else {
		# 普通の怪獣
		$monsterMove[$sx][$sy] = 2;
	    }

	    if(($l == $H2::landDefence) && ($H2::dBaseAuto == 1)) {
		# 防衛施設を踏んだ
		logMonsMoveDefence($id, $name, $lName, $point, $mName);

		# 広域被害ルーチン
		wideDamage($id, $name, $land, $landValue, $sx, $sy);
	    } else {
		# 行き先が荒地になる
		logMonsMove($id, $name, $lName, $point, $mName);
	    }
	}

	# 火災判定
	if((($landKind == $H2::landTown) && ($lv > 30)) ||
	   ($landKind == $H2::landHaribote) ||
	   ($landKind == $H2::landFactory)) {
	    if(random(1000) < $H2::disFire) {
		# 周囲の森と記念碑を数える
		if((countAround($land, $x, $y, $H2::landForest, 7) +
		    countAround($land, $x, $y, $H2::landMonument, 7)) == 0) {
		    # 無かった場合、火災で壊滅
		    my($l) = $land->[$x][$y];
		    my($lv) = $landValue->[$x][$y];
		    my($point) = "($x, $y)";
		    my($lName) = landName($l, $lv);
		    logFire($id, $name, $lName, $point);
		    $land->[$x][$y] = $H2::landWaste;
		    $landValue->[$x][$y] = 0;
		}
	    }
	}
    }
}

# 周囲の町、農場があるか判定
sub countGrow {
    my($land, $landValue, $x, $y) = @_;
    my($i, $sx, $sy);
    for($i = 1; $i < 7; $i++) {
	 $sx = $x + $ax[$i];
	 $sy = $y + $ay[$i];

	 # 行による位置調整
	 if((($sy % 2) == 0) && (($y % 2) == 1)) {
	     $sx--;
	 }

	 if(($sx < 0) || ($sx >= $H2::islandSize) ||
	    ($sy < 0) || ($sy >= $H2::islandSize)) {
	 } else {
	     # 範囲内の場合
	     if(($land->[$sx][$sy] == $H2::landTown) ||
		($land->[$sx][$sy] == $H2::landFarm)) {
		 if($landValue->[$sx][$sy] != 1) {
		     return 1;
		 }
	     }
	 }
    }
    return 0;
}

# 島全体
sub doIslandProcess {
    my($number, $island) = @_;

    # 導出値
    my($name) = $island->{'name'};
    my($id) = $island->{'id'};
    my($land) = $island->{'land'};
    my($landValue) = $island->{'landValue'};

    # 地震判定
    if(random(1000) < (($island->{'prepare2'} + 1) * $H2::disEarthquake)) {
	# 地震発生
	logEarthquake($id, $name);

	my($x, $y, $landKind, $lv, $i);
	for($i = 0; $i < $H2::pointNumber; $i++) {
	    $x = $H2::rpx[$i];
	    $y = $H2::rpy[$i];
	    $landKind = $land->[$x][$y];
	    $lv = $landValue->[$x][$y];

	    if((($landKind == $H2::landTown) && ($lv >= 100)) ||
	       ($landKind == $H2::landHaribote) ||
	       ($landKind == $H2::landFactory)) {
		# 1/4で壊滅
		if(random(4) == 0) {
		    logEQDamage($id, $name, landName($landKind, $lv),
				"($x, $y)");
		    $land->[$x][$y] = $H2::landWaste;
		    $landValue->[$x][$y] = 0;
		}
	    }

	}
    }

    # 食料不足
    if($island->{'food'} < 0) {
	# 不足メッセージ
	logStarve($id, $name);
	$island->{'food'} = 0;

	my($x, $y, $landKind, $lv, $i);
	for($i = 0; $i < $H2::pointNumber; $i++) {
	    $x = $H2::rpx[$i];
	    $y = $H2::rpy[$i];
	    $landKind = $land->[$x][$y];
	    $lv = $landValue->[$x][$y];

	    if(($landKind == $H2::landFarm) ||
	       ($landKind == $H2::landFactory) ||
	       ($landKind == $H2::landBase) ||
	       ($landKind == $H2::landDefence)) {
		# 1/4で壊滅
		if(random(4) == 0) {
		    logSvDamage($id, $name, landName($landKind, $lv),
				"($x, $y)");
		    $land->[$x][$y] = $H2::landWaste;
		    $landValue->[$x][$y] = 0;
		}
	    }
	}
    }

    # 津波判定
    if(random(1000) < $H2::disTsunami) {
	# 津波発生
	logTsunami($id, $name);

	my($x, $y, $landKind, $lv, $i);
	for($i = 0; $i < $H2::pointNumber; $i++) {
	    $x = $H2::rpx[$i];
	    $y = $H2::rpy[$i];
	    $landKind = $land->[$x][$y];
	    $lv = $landValue->[$x][$y];

	    if(($landKind == $H2::landTown) ||
	       ($landKind == $H2::landFarm) ||
	       ($landKind == $H2::landFactory) ||
	       ($landKind == $H2::landBase) ||
	       ($landKind == $H2::landDefence) ||
	       ($landKind == $H2::landHaribote)) {
		# 1d12 <= (周囲の海 - 1) で崩壊
		if(random(12) <
		   (countAround($land, $x, $y, $H2::landOil, 7) +
		    countAround($land, $x, $y, $H2::landSbase, 7) +
		    countAround($land, $x, $y, $H2::landSea, 7) - 1)) {
		    logTsunamiDamage($id, $name, landName($landKind, $lv),
				     "($x, $y)");
		    $land->[$x][$y] = $H2::landWaste;
		    $landValue->[$x][$y] = 0;
		}
	    }

	}
    }

    # 怪獣判定
    my($r) = random(10000);
    my($pop) = $island->{'pop'};
    do{
	if((($r < ($H2::disMonster * $island->{'area'})) &&
	    ($pop >= $H2::disMonsBorder1)) ||
	   ($island->{'monstersend'} > 0)) {
	    # 怪獣出現
	    # 種類を決める
	    my($lv, $kind);
	    if($island->{'monstersend'} > 0) {
		# 人造
		$kind = 0;
		$island->{'monstersend'}--;
	    } elsif($pop >= $H2::disMonsBorder3) {
		# level3まで
		$kind = random($H2::monsterLevel3) + 1;
	    } elsif($pop >= $H2::disMonsBorder2) {
		# level2まで
		$kind = random($H2::monsterLevel2) + 1;
	    } else {
		# level1のみ
		$kind = random($H2::monsterLevel1) + 1;
	    }

	    # lvの値を決める
	    $lv = $kind * 10
		+ $H2::monsterBHP[$kind] + random($H2::monsterDHP[$kind]);

	    # どこに現れるか決める
	    my($bx, $by, $i);
	    for($i = 0; $i < $H2::pointNumber; $i++) {
		$bx = $H2::rpx[$i];
		$by = $H2::rpy[$i];
		if($land->[$bx][$by] == $H2::landTown) {

		    # 地形名
		    my($lName) = landName($H2::landTown, $landValue->[$bx][$by]);

		    # そのヘックスを怪獣に
		    $land->[$bx][$by] = $H2::landMonster;
		    $landValue->[$bx][$by] = $lv;

		    # 怪獣情報
		    my($mKind, $mName, $mHp) = monsterSpec($lv);

		    # メッセージ
		    logMonsCome($id, $name, $mName, "($bx, $by)", $lName);
		    last;
		}
	    }
	}
    } while($island->{'monstersend'} > 0);

    # 地盤沈下判定
    if(($island->{'area'} > $H2::disFallBorder) &&
       (random(1000) < $H2::disFalldown)) {
	# 地盤沈下発生
	logFalldown($id, $name);

	my($x, $y, $landKind, $lv, $i);
	for($i = 0; $i < $H2::pointNumber; $i++) {
	    $x = $H2::rpx[$i];
	    $y = $H2::rpy[$i];
	    $landKind = $land->[$x][$y];
	    $lv = $landValue->[$x][$y];

	    if(($landKind != $H2::landSea) &&
	       ($landKind != $H2::landSbase) &&
	       ($landKind != $H2::landOil) &&
	       ($landKind != $H2::landMountain)) {

		# 周囲に海があれば、値を-1に
		if(countAround($land, $x, $y, $H2::landSea, 7) + 
		   countAround($land, $x, $y, $H2::landSbase, 7)) {
		    logFalldownLand($id, $name, landName($landKind, $lv),
				"($x, $y)");
		    $land->[$x][$y] = -1;
		    $landValue->[$x][$y] = 0;
		}
	    }
	}

	for($i = 0; $i < $H2::pointNumber; $i++) {
	    $x = $H2::rpx[$i];
	    $y = $H2::rpy[$i];
	    $landKind = $land->[$x][$y];

	    if($landKind == -1) {
		# -1になっている所を浅瀬に
		$land->[$x][$y] = $H2::landSea;
		$landValue->[$x][$y] = 1;
	    } elsif ($landKind == $H2::landSea) {
		# 浅瀬は海に
		$landValue->[$x][$y] = 0;
	    }

	}
    }

    # 台風判定
    if(random(1000) < $H2::disTyphoon) {
	# 台風発生
	logTyphoon($id, $name);

	my($x, $y, $landKind, $lv, $i);
	for($i = 0; $i < $H2::pointNumber; $i++) {
	    $x = $H2::rpx[$i];
	    $y = $H2::rpy[$i];
	    $landKind = $land->[$x][$y];
	    $lv = $landValue->[$x][$y];

	    if(($landKind == $H2::landFarm) ||
	       ($landKind == $H2::landHaribote)) {

		# 1d12 <= (6 - 周囲の森) で崩壊
		if(random(12) < 
		   (6
		    - countAround($land, $x, $y, $H2::landForest, 7)
		    - countAround($land, $x, $y, $H2::landMonument, 7))) {
		    logTyphoonDamage($id, $name, landName($landKind, $lv),
				     "($x, $y)");
		    $land->[$x][$y] = $H2::landPlains;
		    $landValue->[$x][$y] = 0;
		}
	    }

	}
    }

    # 巨大隕石判定
    if(random(1000) < $H2::disHugeMeteo) {
	my($x, $y, $landKind, $lv, $point);

	# 落下
	$x = random($H2::islandSize);
	$y = random($H2::islandSize);
	$landKind = $land->[$x][$y];
	$lv = $landValue->[$x][$y];
	$point = "($x, $y)";

	# メッセージ
	logHugeMeteo($id, $name, $point);

	# 広域被害ルーチン
	wideDamage($id, $name, $land, $landValue, $x, $y);
    }

    # 巨大ミサイル判定
    while($island->{'bigmissile'} > 0) {
	$island->{'bigmissile'} --;

	my($x, $y, $landKind, $lv, $point);

	# 落下
	$x = random($H2::islandSize);
	$y = random($H2::islandSize);
	$landKind = $land->[$x][$y];
	$lv = $landValue->[$x][$y];
	$point = "($x, $y)";

	# メッセージ
	logMonDamage($id, $name, $point);

	# 広域被害ルーチン
	wideDamage($id, $name, $land, $landValue, $x, $y);
    }

    # 隕石判定
    if(random(1000) < $H2::disMeteo) {
	my($x, $y, $landKind, $lv, $point, $first);
	$first = 1;
	while((random(2) == 0) || ($first == 1)) {
	    $first = 0;
	    
	    # 落下
	    $x = random($H2::islandSize);
	    $y = random($H2::islandSize);
	    $landKind = $land->[$x][$y];
	    $lv = $landValue->[$x][$y];
	    $point = "($x, $y)";

	    if(($landKind == $H2::landSea) && ($lv == 0)){
		# 海ポチャ
		logMeteoSea($id, $name, landName($landKind, $lv),
			    $point);
	    } elsif($landKind == $H2::landMountain) {
		# 山破壊
		logMeteoMountain($id, $name, landName($landKind, $lv),
				 $point);
		$land->[$x][$y] = $H2::landWaste;
		$landValue->[$x][$y] = 0;
		next;
	    } elsif($landKind == $H2::landSbase) {
		logMeteoSbase($id, $name, landName($landKind, $lv),
			      $point);
	    } elsif($landKind == $H2::landMonster) {
		logMeteoMonster($id, $name, landName($landKind, $lv),
				$point);
	    } elsif($landKind == $H2::landSea) {
		# 浅瀬
		logMeteoSea1($id, $name, landName($landKind, $lv),
			     $point);
	    } else {
		logMeteoNormal($id, $name, landName($landKind, $lv),
			       $point);
	    }
	    $land->[$x][$y] = $H2::landSea;
	    $landValue->[$x][$y] = 0;
	}
    }

    # 噴火判定
    if(random(1000) < $H2::disEruption) {
	my($x, $y, $sx, $sy, $i, $landKind, $lv, $point);
	$x = random($H2::islandSize);
	$y = random($H2::islandSize);
	$landKind = $land->[$x][$y];
	$lv = $landValue->[$x][$y];
	$point = "($x, $y)";
	logEruption($id, $name, landName($landKind, $lv),
		    $point);
	$land->[$x][$y] = $H2::landMountain;
	$landValue->[$x][$y] = 0;

	for($i = 1; $i < 7; $i++) {
	    $sx = $x + $ax[$i];
	    $sy = $y + $ay[$i];

	    # 行による位置調整
	    if((($sy % 2) == 0) && (($y % 2) == 1)) {
		$sx--;
	    }

	    $landKind = $land->[$sx][$sy];
	    $lv = $landValue->[$sx][$sy];
	    $point = "($sx, $sy)";

	    if(($sx < 0) || ($sx >= $H2::islandSize) ||
	       ($sy < 0) || ($sy >= $H2::islandSize)) {
	    } else {
		# 範囲内の場合
		$landKind = $land->[$sx][$sy];
		$lv = $landValue->[$sx][$sy];
		$point = "($sx, $sy)";
		if(($landKind == $H2::landSea) ||
		   ($landKind == $H2::landOil) ||
		   ($landKind == $H2::landSbase)) {
		    # 海の場合
		    if($lv == 1) {
			# 浅瀬
			logEruptionSea1($id, $name, landName($landKind, $lv),
					$point);
		    } else {
			logEruptionSea($id, $name, landName($landKind, $lv),
				       $point);
			$land->[$sx][$sy] = $H2::landSea;
			$landValue->[$sx][$sy] = 1;
			next;
		    }
		} elsif(($landKind == $H2::landMountain) ||
			($landKind == $H2::landMonster) ||
			($landKind == $H2::landWaste)) {
		    next;
		} else {
		    # それ以外の場合
		    logEruptionNormal($id, $name, landName($landKind, $lv),
				      $point);
		}
		$land->[$sx][$sy] = $H2::landWaste;
		$landValue->[$sx][$sy] = 0;
	    }
	}
    }

    # 食料があふれてたら換金
    if($island->{'food'} > 9999) {
	$island->{'money'} += int(($island->{'food'} - 9999) / 10);
	$island->{'food'} = 9999;
    } 

    # 金があふれてたら切り捨て
    if($island->{'money'} > 9999) {
	$island->{'money'} = 9999;
    } 

    # 各種の値を計算
    estimate($number);

    # 各種勲章受賞
    my($prize) = $island->{'prize'};
    $prize =~ /([0-9]*),([0-9]*),(.*)/;
    my($flags) = $1;
    my($monsters) = $2;
    my($turns) = $3;
    
    my($value, $thres, $p);
    my($f) = 1;
    for ( $p=1; $p < $H2::prizeNumber; $p++ ) {
	if (!($flags & $f)) {
	    $value = $island->{'ext'}[$H2::prize[$p]->{'ptr'}];
	    $thres = $H2::prize[$p]->{'threshold'};
	    if ($value >= $thres) {
		$flags |= $f; # 受勲
		$island->{'ext'}[1] += $H2::prize[$p]->{'contribution'}; # 貢献度up
		logPrize($id, $name, $H2::prize[$p]->{'name'});
	    }
	}
	$f *= 2;
    }

    $island->{'prize'} = "$flags,$monsters,$turns";
}

# 人口順にソート
sub islandSort {
    my($flag, $i, $tmp);

    # 人口が同じときは直前のターンの順番のまま
    my @idx = (0..$#H2::islands);
    @idx = sort { $H2::islands[$b]->{'pop'} <=> $H2::islands[$a]->{'pop'} || $a <=> $b } @idx;
    @H2::islands = @H2::islands[@idx];
}

# 人口順にソート(陣営バージョン)
sub campSort {
    my($flag, $i, $tmp);

    # 人口が同じときは直前のターンの順番のまま
    my @idx = (0..$#H2::camp);
    @idx = sort { $H2::camp[$b]->{'score'} <=> $H2::camp[$a]->{'score'} || $a <=> $b } @idx;
    @H2::camp = @H2::camp[@idx];
}


# 広域被害ルーチン
sub wideDamage {
    my($id, $name, $land, $landValue, $x, $y) = @_;
    my($sx, $sy, $i, $landKind, $landName, $lv, $point);

    for($i = 0; $i < 19; $i++) {
	$sx = $x + $ax[$i];
	$sy = $y + $ay[$i];

	# 行による位置調整
	if((($sy % 2) == 0) && (($y % 2) == 1)) {
	    $sx--;
	}
    
	$landKind = $land->[$sx][$sy];
	$lv = $landValue->[$sx][$sy];
	$landName = landName($landKind, $lv);
	$point = "($sx, $sy)";

	# 範囲外判定
	if(($sx < 0) || ($sx >= $H2::islandSize) ||
	   ($sy < 0) || ($sy >= $H2::islandSize)) {
	    next;
	}

	# 範囲による分岐
	if($i < 7) {
	    # 中心、および1ヘックス
	    if($landKind == $H2::landSea) {
		$landValue->[$sx][$sy] = 0;
		next;
	    } elsif(($landKind == $H2::landSbase) ||
		    ($landKind == $H2::landOil)) {
		logWideDamageSea2($id, $name, $landName, $point);
		$land->[$sx][$sy] = $H2::landSea;
		$landValue->[$sx][$sy] = 0;
	    } else {
		if($landKind == $H2::landMonster) {
		    logWideDamageMonsterSea($id, $name, $landName, $point);
		} else {
		    logWideDamageSea($id, $name, $landName, $point);
		}
		$land->[$sx][$sy] = $H2::landSea;
		if($i == 0) {
		    # 海
		    $landValue->[$sx][$sy] = 0;
		} else {
		    # 浅瀬
		    $landValue->[$sx][$sy] = 1;
		}
	    }
	} else {
	    # 2ヘックス
	    if(($landKind == $H2::landSea) ||
	       ($landKind == $H2::landOil) ||
	       ($landKind == $H2::landWaste) ||
	       ($landKind == $H2::landMountain) ||
	       ($landKind == $H2::landSbase)) {
		next;
	    } elsif($landKind == $H2::landMonster) {
		logWideDamageMonster($id, $name, $landName, $point);
		$land->[$sx][$sy] = $H2::landWaste;
		$landValue->[$sx][$sy] = 0;
	    } else {
		logWideDamageWaste($id, $name, $landName, $point);
		$land->[$sx][$sy] = $H2::landWaste;
		$landValue->[$sx][$sy] = 0;
	    }
	}
    }
}

# ログへの出力
# 第1引数:メッセージ
# 第2引数:当事者
# 第3引数:相手
# 通常ログ
sub logOut {
    push(@H2::logPool,"0,$H2::islandTurn,$_[1],$_[2],$_[0]");
}

# 遅延ログ
sub logLate {
    push(@H2::lateLogPool,"0,$H2::islandTurn,$_[1],$_[2],$_[0]");
}

# 機密ログ
sub logSecret {
    push(@H2::secretLogPool,"1,$H2::islandTurn,$_[1],$_[2],$_[0]");
}

# 記録ログ
sub logHistory {
    open(HOUT, ">>${H2::dirName}/hakojima.his");
    print HOUT "$H2::islandTurn,$_[0]\n";
    close(HOUT);
}

# 記録ログ調整
sub logHistoryTrim {
    open(HIN, "${H2::dirName}/hakojima.his");
    my(@line, $l, $count);
    $count = 0;
    while($l = <HIN>) {
	chomp($l);
	push(@line, $l);
	$count++;
    }
    close(HIN);

    if($count > $H2::historyMax) {
	open(HOUT, ">${H2::dirName}/hakojima.his");
	my($i);
	for($i = ($count - $H2::historyMax); $i < $count; $i++) {
	    print HOUT "$line[$i]\n";
	}
	close(HOUT);
    }
}

# ログ書き出し
sub logFlush {
    open(LOUT, ">${H2::dirName}/hakojima.log0");

    # 全部逆順にして書き出す
    my($i);
    for($i = $#H2::secretLogPool; $i >= 0; $i--) {
	print LOUT $H2::secretLogPool[$i];
	print LOUT "\n";
    }
    for($i = $#H2::lateLogPool; $i >= 0; $i--) {
	print LOUT $H2::lateLogPool[$i];
	print LOUT "\n";
    }
    for($i = $#H2::logPool; $i >= 0; $i--) {
	print LOUT $H2::logPool[$i];
	print LOUT "\n";
    }
    close(LOUT);
}

sub remakeCampPasswd {
    my($i);
    for ($i = 0; $i < $H2::campNumber; $i++) {
	$H2::camp[$i]->{'passward'} = makeRandomString() . $i;
    }
}

#----------------------------------------------------------------------
# ログテンプレート
#----------------------------------------------------------------------
# 資金足りない
sub logNoMoney {
    my($id, $name, $comName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagComName_}$comName${H2::_tagComName}は、資金不足のため中止されました。",$id);
}

# 食料足りない
sub logNoFood {
    my($id, $name, $comName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagComName_}$comName${H2::_tagComName}は、備蓄食料不足のため中止されました。",$id);
}

# 対象地形の種類による失敗
sub logLandFail {
    my($id, $name, $comName, $kind, $point) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagComName_}$comName${H2::_tagComName}は、予定地の${H2::tagName_}$point${H2::_tagName}が<B>$kind</B>だったため中止されました。",$id);
END
}

# 周りに陸がなくて埋め立て失敗
sub logNoLandAround {
    my($id, $name, $comName, $point) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagComName_}$comName${H2::_tagComName}は、予定地の${H2::tagName_}$point${H2::_tagName}の周辺に陸地がなかったため中止されました。",$id);
END
}

# 整地系成功
sub logLandSuc {
    my($id, $name, $comName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}で${H2::tagComName_}${comName}${H2::_tagComName}が行われました。",$id);
END
}

# 油田発見
sub logOilFound {
    my($id, $name, $point, $comName, $str) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}で<B>$str</B>の予算をつぎ込んだ${H2::tagComName_}${comName}${H2::_tagComName}が行われ、<B>油田が掘り当てられました</B>。",$id);
END
}

# 油田発見ならず
sub logOilFail {
    my($id, $name, $point, $comName, $str) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}で<B>$str</B>の予算をつぎ込んだ${H2::tagComName_}${comName}${H2::_tagComName}が行われましたが、油田は見つかりませんでした。",$id);
END
}

# 油田からの収入
sub logOilMoney {
    my($id, $name, $lName, $point, $str) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>から、<B>$str</B>の収益が上がりました。",$id);
END
}

# 油田枯渇
sub logOilEnd {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は枯渇したようです。",$id);
END
}

# 防衛施設、自爆セット
sub logBombSet {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>の<B>自爆装置がセット</B>されました。",$id);
END
}

# 防衛施設、自爆作動
sub logBombFire {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>、${H2::tagDisaster_}自爆装置作動！！${H2::_tagDisaster}",$id);
END
}

# 記念碑、発射
sub logMonFly {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>が<B>轟音とともに飛び立ちました</B>。",$id);
END
}

# 記念碑、落下
sub logMonDamage {
    my($id, $name, $point) = @_;
    logOut("<B>何かとてつもないもの</B>が${H2::tagName_}${name}島$point${H2::_tagName}地点に落下しました！！",$id);
}

# 植林orミサイル基地or防衛施設
sub logPBSuc {
    my($id, $name, $comName, $point) = @_;
    logSecret("${H2::tagName_}${name}島$point${H2::_tagName}で${H2::tagComName_}${comName}${H2::_tagComName}が行われました。",$id);
    logOut("こころなしか、${H2::tagName_}${name}島${H2::_tagName}の<B>森</B>が増えたようです。",$id);
END
}

# ハリボテ
sub logHariSuc {
    my($id, $name, $comName, $comName2, $point) = @_;
    logSecret("${H2::tagName_}${name}島$point${H2::_tagName}で${H2::tagComName_}${comName}${H2::_tagComName}が行われました。",$id);
    logLandSuc($id, $name, $comName2, $point);
END
}

# ミサイル撃とうとした(or 怪獣派遣しようとした)がターゲットがいない
sub logMsNoTarget {
    my($id, $name, $comName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagComName_}${comName}${H2::_tagComName}は、目標の島に人が見当たらないため中止されました。",$id);
END
}

# ミサイル撃とうとしたが基地がない
sub logMsNoBase {
    my($id, $name, $comName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagComName_}${comName}${H2::_tagComName}は、<B>ミサイル設備を保有していない</B>ために実行できませんでした。",$id);
END
}

# ミサイル撃ったが範囲外
sub logMsOut {
    my($id, $tId, $name, $tName, $comName, $point) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、<B>領域外の海</B>に落ちた模様です。",$id, $tId);
}

# ステルスミサイル撃ったが範囲外
sub logMsOutS {
    my($id, $tId, $name, $tName, $comName, $point) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、<B>領域外の海</B>に落ちた模様です。",$id, $tId);
    logLate("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}へ向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、<B>領域外の海</B>に落ちた模様です。",$tId);
}

# ミサイル撃ったが防衛施設でキャッチ
sub logMsCaught {
    my($id, $tId, $name, $tName, $comName, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}地点上空にて力場に捉えられ、<B>空中爆発</B>しました。",$id, $tId);
}

# ステルスミサイル撃ったが防衛施設でキャッチ
sub logMsCaughtS {
    my($id, $tId, $name, $tName, $comName, $point, $tPoint) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}地点上空にて力場に捉えられ、<B>空中爆発</B>しました。",$id, $tId);
    logLate("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}へ向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}地点上空にて力場に捉えられ、<B>空中爆発</B>しました。",$tId);
}

# ミサイル撃ったが効果なし
sub logMsNoDamage {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に落ちたので被害がありませんでした。",$id, $tId);
}

# ステルスミサイル撃ったが効果なし
sub logMsNoDamageS {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に落ちたので被害がありませんでした。",$id, $tId);

    logLate("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に落ちたので被害がありませんでした。",$tId);
}

# 陸地破壊弾、山に命中
sub logMsLDMountain {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に命中。<B>$tLname</B>は消し飛び、荒地と化しました。",$id, $tId);
}

# 陸地破壊弾、海底基地に命中
sub logMsLDSbase {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}に着水後爆発、同地点にあった<B>$tLname</B>は跡形もなく吹き飛びました。",$id, $tId);
}

# 陸地破壊弾、怪獣に命中
sub logMsLDMonster {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}に着弾し爆発。陸地は<B>怪獣$tLname</B>もろとも水没しました。",$id, $tId);
}

# 陸地破壊弾、浅瀬に命中
sub logMsLDSea1 {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に着弾。海底がえぐられました。",$id, $tId);
}

# 陸地破壊弾、その他の地形に命中
sub logMsLDLand {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に着弾。陸地は水没しました。",$id, $tId);
}

# 通常ミサイル、荒地に着弾
sub logMsWaste {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に落ちました。",$id, $tId);
}

# ステルスミサイル、荒地に着弾
sub logMsWasteS {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に落ちました。",$id, $tId);
    logLate("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行いましたが、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に落ちました。",$tId);
}

# 通常ミサイル、怪獣に命中、硬化中にて無傷
sub logMsMonNoDamage {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中、しかし硬化状態だったため効果がありませんでした。",$id, $tId);
}

# ステルスミサイル、怪獣に命中、硬化中にて無傷
sub logMsMonNoDamageS {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中、しかし硬化状態だったため効果がありませんでした。",$id, $tId);
    logOut("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中、しかし硬化状態だったため効果がありませんでした。",$tId);
}

# 通常ミサイル、怪獣に命中、殺傷
sub logMsMonKill {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中。<B>怪獣$tLname</B>は力尽き、倒れました。",$id, $tId);
}

# ステルスミサイル、怪獣に命中、殺傷
sub logMsMonKillS {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中。<B>怪獣$tLname</B>は力尽き、倒れました。",$id, $tId);
    logLate("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中。<B>怪獣$tLname</B>は力尽き、倒れました。", $tId);
}

# 通常ミサイル、怪獣に命中、ダメージ
sub logMsMonster {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中。<B>怪獣$tLname</B>は苦しそうに咆哮しました。",$id, $tId);
}

# ステルスミサイル、怪獣に命中、ダメージ
sub logMsMonsterS {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中。<B>怪獣$tLname</B>は苦しそうに咆哮しました。",$id, $tId);
    logLate("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>怪獣$tLname</B>に命中。<B>怪獣$tLname</B>は苦しそうに咆哮しました。",$tId);
}

# 怪獣の死体
sub logMsMonMoney {
    my($tId, $mName, $value) = @_;
    logOut("<B>怪獣$mName</B>の残骸には、<B>$value$H2::unitMoney</B>の値が付きました。",$tId);
}

# 通常ミサイル通常地形に命中
sub logMsNormal {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に命中、一帯が壊滅しました。",$id, $tId);
}

# ステルスミサイル通常地形に命中
sub logMsNormalS {
    my($id, $tId, $name, $tName, $comName, $tLname, $point, $tPoint) = @_;
    logSecret("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に命中、一帯が壊滅しました。",$id, $tId);
    logLate("<B>何者か</B>が${H2::tagName_}${tName}島$point${H2::_tagName}地点に向けて${H2::tagComName_}${comName}${H2::_tagComName}を行い、${H2::tagName_}$tPoint${H2::_tagName}の<B>$tLname</B>に命中、一帯が壊滅しました。",$tId);
}

# ミサイル難民到着
sub logMsBoatPeople {
    my($id, $name, $achive) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}にどこからともなく<B>$achive${H2::unitPop}もの難民</B>が漂着しました。${H2::tagName_}${name}島${H2::_tagName}は快く受け入れたようです。",$id);
}

# 怪獣派遣
sub logMonsSend {
    my($id, $tId, $name, $tName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が<B>人造怪獣</B>を建造。${H2::tagName_}${tName}島${H2::_tagName}へ送りこみました。",$id, $tId);
}

# 資金繰り
sub logDoNothing {
    my($id, $name, $comName) = @_;
#    logOut("${H2::tagName_}${name}島${H2::_tagName}で${H2::tagComName_}${comName}${H2::_tagComName}が行われました。",$id);
}

# 輸出
sub logSell {
    my($id, $name, $comName, $value) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が<B>$value$H2::unitFood</B>の${H2::tagComName_}${comName}${H2::_tagComName}を行いました。",$id);
}

# 援助
sub logAid {
    my($id, $tId, $name, $tName, $comName, $str) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が${H2::tagName_}${tName}島${H2::_tagName}へ<B>$str</B>の${H2::tagComName_}${comName}${H2::_tagComName}を行いました。",$id, $tId);
}

# 陣営外への援助（不許可）
sub logAidFail {
    my($id, $tId, $name, $tName, $comName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagName_}${tName}島${H2::_tagName}への${H2::tagComName_}${comName}${H2::_tagComName}は許可されていないため中止しました。",$id, $tId);
}

# 攻撃禁止
sub logNotAvail {
    my($id, $name, $comName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で予定されていた${H2::tagComName_}${comName}${H2::_tagComName}は許可されていないため中止しました。",$id);
}

# 誘致活動
sub logPropaganda {
    my($id, $name, $comName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で${H2::tagComName_}${comName}${H2::_tagComName}が行われました。",$id);
}

# 放棄
sub logGiveup {
    my($id, $name) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}は放棄され、<B>無人島</B>になりました。",$id);
    logHistory("${H2::tagName_}${name}島${H2::_tagName}、放棄され<B>無人島</B>となる。");
}

# 死滅
sub logDead {
    my($id, $name) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}から人がいなくなり、<B>無人島</B>になりました。",$id);
    logHistory("${H2::tagName_}${name}島${H2::_tagName}、人がいなくなり<B>無人島</B>となる。");
}

# 死滅
sub logDeleteIsland {
    my($id, $name) = @_;
    logHistory("${H2::tagName_}${name}島${H2::_tagName}、神の裁きにより<B>退場</B>となる。");
}

# 発見
sub logDiscover {
    my($name) = @_;
    logHistory("${H2::tagName_}${name}島${H2::_tagName}が発見される。");
}

# 名前の変更
sub logChangeName {
    my($name1, $name2) = @_;
    logHistory("${H2::tagName_}${name1}島${H2::_tagName}、名称を${H2::tagName_}${name2}島${H2::_tagName}に変更する。");
}

# 飢餓
sub logStarve {
    my($id, $name) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}の${H2::tagDisaster_}食料が不足${H2::_tagDisaster}しています！！",$id);
}

# 怪獣現る
sub logMonsCome {
    my($id, $name, $mName, $point, $lName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}に<B>怪獣$mName</B>出現！！${H2::tagName_}$point${H2::_tagName}の<B>$lName</B>が踏み荒らされました。",$id);
}

# 怪獣動く
sub logMonsMove {
    my($id, $name, $lName, $point, $mName) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>が<B>怪獣$mName</B>に踏み荒らされました。",$id);
}

# 怪獣、防衛施設を踏む
sub logMonsMoveDefence {
    my($id, $name, $lName, $point, $mName) = @_;
    logOut("<B>怪獣$mName</B>が${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>へ到達、<B>${lName}の自爆装置が作動！！</B>",$id);
}

# 火災
sub logFire {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>が${H2::tagDisaster_}火災${H2::_tagDisaster}により壊滅しました。",$id);
}

# 埋蔵金
sub logMaizo {
    my($id, $name, $comName, $value) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}での${H2::tagComName_}$comName${H2::_tagComName}中に、<B>$value$H2::unitMoneyもの埋蔵金</B>が発見されました。",$id);
}

# 地震発生
sub logEarthquake {
    my($id, $name) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で大規模な${H2::tagDisaster_}地震${H2::_tagDisaster}が発生！！",$id);
}

# 地震被害
sub logEQDamage {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は${H2::tagDisaster_}地震${H2::_tagDisaster}により壊滅しました。",$id);
}

# 食料不足被害
sub logSvDamage {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>に<B>食料を求めて住民が殺到</B>。<B>$lName</B>は壊滅しました。",$id);
}

# 津波発生
sub logTsunami {
    my($id, $name) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}付近で${H2::tagDisaster_}津波${H2::_tagDisaster}発生！！",$id);
}

# 津波被害
sub logTsunamiDamage {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は${H2::tagDisaster_}津波${H2::_tagDisaster}により崩壊しました。",$id);
}

# 台風発生
sub logTyphoon {
    my($id, $name) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}に${H2::tagDisaster_}台風${H2::_tagDisaster}上陸！！",$id);
}

# 台風被害
sub logTyphoonDamage {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は${H2::tagDisaster_}台風${H2::_tagDisaster}で飛ばされました。",$id);
}

# 隕石、海
sub logMeteoSea {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>に${H2::tagDisaster_}隕石${H2::_tagDisaster}が落下しました。",$id);
}

# 隕石、山
sub logMeteoMountain {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>に${H2::tagDisaster_}隕石${H2::_tagDisaster}が落下、<B>$lName</B>は消し飛びました。",$id);
}

# 隕石、海底基地
sub logMeteoSbase {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>に${H2::tagDisaster_}隕石${H2::_tagDisaster}が落下、<B>$lName</B>は崩壊しました。",$id);
}

# 隕石、怪獣
sub logMeteoMonster {
    my($id, $name, $lName, $point) = @_;
    logOut("<B>怪獣$lName</B>がいた${H2::tagName_}${name}島$point${H2::_tagName}地点に${H2::tagDisaster_}隕石${H2::_tagDisaster}が落下、陸地は<B>怪獣$lName</B>もろとも水没しました。",$id);
}

# 隕石、浅瀬
sub logMeteoSea1 {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}地点に${H2::tagDisaster_}隕石${H2::_tagDisaster}が落下、海底がえぐられました。",$id);
}

# 隕石、その他
sub logMeteoNormal {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}地点の<B>$lName</B>に${H2::tagDisaster_}隕石${H2::_tagDisaster}が落下、一帯が水没しました。",$id);
}

# 隕石、その他
sub logHugeMeteo {
    my($id, $name, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}地点に${H2::tagDisaster_}巨大隕石${H2::_tagDisaster}が落下！！",$id);
}

# 噴火
sub logEruption {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}地点で${H2::tagDisaster_}火山が噴火${H2::_tagDisaster}、<B>山</B>が出来ました。",$id);
}

# 噴火、浅瀬
sub logEruptionSea1 {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}地点の<B>$lName</B>は、${H2::tagDisaster_}噴火${H2::_tagDisaster}の影響で陸地になりました。",$id);
}

# 噴火、海or海基
sub logEruptionSea {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}地点の<B>$lName</B>は、${H2::tagDisaster_}噴火${H2::_tagDisaster}の影響で海底が隆起、浅瀬になりました。",$id);
}

# 噴火、その他
sub logEruptionNormal {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}地点の<B>$lName</B>は、${H2::tagDisaster_}噴火${H2::_tagDisaster}の影響で壊滅しました。",$id);
}

# 地盤沈下発生
sub logFalldown {
    my($id, $name) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}で${H2::tagDisaster_}地盤沈下${H2::_tagDisaster}が発生しました！！",$id);
}

# 地盤沈下被害
sub logFalldownLand {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は海の中へ沈みました。",$id);
}

# 広域被害、水没
sub logWideDamageSea {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は<B>水没</B>しました。",$id);
}

# 広域被害、海の建設
sub logWideDamageSea2 {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は跡形もなくなりました。",$id);
}

# 広域被害、怪獣水没
sub logWideDamageMonsterSea {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の陸地は<B>怪獣$lName</B>もろとも水没しました。",$id);
}

# 広域被害、怪獣
sub logWideDamageMonster {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>怪獣$lName</B>は消し飛びました。",$id);
}

# 広域被害、荒地
sub logWideDamageWaste {
    my($id, $name, $lName, $point) = @_;
    logOut("${H2::tagName_}${name}島$point${H2::_tagName}の<B>$lName</B>は一瞬にして<B>荒地</B>と化しました。",$id);
}

# 受賞
sub logPrize {
    my($id, $name, $pName) = @_;
    logOut("${H2::tagName_}${name}島${H2::_tagName}が<B>$pName</B>を受賞しました。",$id);
    logHistory("${H2::tagName_}${name}島${H2::_tagName}、<B>$pName</B>を受賞");
}

# 陣営消滅
sub logCampDelete {
    my($name) = @_;
    logHistory("${H2::tagName_}${name}${H2::_tagName}は、滅亡しました。");
}

# 島がいっぱいな場合
sub tempNewIslandFull {
    out(<<END);
${H2::tagBig_}申し訳ありません、島が一杯で登録できません！！${H2::_tagBig}$H2::tempBack
END
}

# 新規で名前がない場合
sub tempNewIslandNoName {
    out(<<END);
${H2::tagBig_}島につける名前が必要です。${H2::_tagBig}$H2::tempBack
END
}

# 新規で名前が不正な場合
sub tempNewIslandBadName {
    out(<<END);
${H2::tagBig_}',?()<>\$'とか入ってたり、「無人島」とかいった変な名前はやめましょうよ〜${H2::_tagBig}$H2::tempBack
END
}

# すでにその名前の島がある場合
sub tempNewIslandAlready {
    out(<<END);
${H2::tagBig_}その島ならすでに発見されています。${H2::_tagBig}$H2::tempBack
END
}

# パスワードがない場合
sub tempNewIslandNoPassword {
    out(<<END);
${H2::tagBig_}パスワードが必要です。${H2::_tagBig}$H2::tempBack
END
}

# 島を発見しました!!
sub tempNewIslandHead {
    out(<<END);
<CENTER>
${H2::tagBig_}島を発見しました！！${H2::_tagBig}<BR>
${H2::tagBig_}${H2::tagName_}「${H2::currentName}島」${H2::_tagName}と命名します。${H2::_tagBig}<BR>
$H2::tempBack<BR>
</CENTER>
END
}

# 地形の呼び方
sub landName {
    my($land, $lv) = @_;
    if($land == $H2::landSea) {
	if($lv == 1) {
            return '浅瀬';
        } else {
            return '海';
	}
    } elsif($land == $H2::landWaste) {
	return '荒地';
    } elsif($land == $H2::landPlains) {
	return '平地';
    } elsif($land == $H2::landTown) {
	if($lv < 30) {
	    return '村';
	} elsif($lv < 100) {
	    return '町';
	} else {
	    return '都市';
	}
    } elsif($land == $H2::landForest) {
	return '森';
    } elsif($land == $H2::landFarm) {
	return '農場';
    } elsif($land == $H2::landFactory) {
	return '工場';
    } elsif($land == $H2::landBase) {
	return 'ミサイル基地';
    } elsif($land == $H2::landDefence) {
	return '防衛施設';
    } elsif($land == $H2::landMountain) {
	return '山';
    } elsif($land == $H2::landMonster) {
	my($kind, $name, $hp) = monsterSpec($lv);
	return $name;
    } elsif($land == $H2::landSbase) {
	return '海底基地';
    } elsif($land == $H2::landOil) {
	return '海底油田';
    } elsif($land == $H2::landMonument) {
	return $H2::monumentName[$lv];
    } elsif($land == $H2::landHaribote) {
	return 'ハリボテ';
    }
}

# 人口その他の値を算出
sub estimate {
    my($number) = $_[0];
    my($island);
    my($pop, $area, $farm, $factory, $mountain) = (0, 0, 0, 0, 0, 0);

    # 地形を取得
    $island = $H2::islands[$number];
    my($land) = $island->{'land'};
    my($landValue) = $island->{'landValue'};

    # 数える
    my($x, $y, $kind, $value);
    for($y = 0; $y < $H2::islandSize; $y++) {
	for($x = 0; $x < $H2::islandSize; $x++) {
	    $kind = $land->[$x][$y];
	    $value = $landValue->[$x][$y];
	    if(($kind != $H2::landSea) &&
	       ($kind != $H2::landSbase) &&
	       ($kind != $H2::landOil)){
		$area++;
		if($kind == $H2::landTown) {
		    # 町
		    $pop += $value;
		} elsif($kind == $H2::landFarm) {
		    # 農場
		    $farm += $value;
		} elsif($kind == $H2::landFactory) {
		    # 工場
		    $factory += $value;
		} elsif($kind == $H2::landMountain) {
		    # 山
		    $mountain += $value;
		}
	    }
	}
    }

    # 代入
    $island->{'pop'}      = $pop;
    $island->{'area'}     = $area;
    $island->{'farm'}     = $farm;
    $island->{'factory'}  = $factory;
    $island->{'mountain'} = $mountain;
}


# 範囲内の地形を数える
sub countAround {
    my($land, $x, $y, $kind, $range) = @_;
    my($i, $count, $sx, $sy);
    $count = 0;
    for($i = 0; $i < $range; $i++) {
	 $sx = $x + $ax[$i];
	 $sy = $y + $ay[$i];

	 # 行による位置調整
	 if((($sy % 2) == 0) && (($y % 2) == 1)) {
	     $sx--;
	 }

	 if(($sx < 0) || ($sx >= $H2::islandSize) ||
	    ($sy < 0) || ($sy >= $H2::islandSize)) {
	     # 範囲外の場合
	     if($kind == $H2::landSea) {
		 # 海なら加算
		 $count++;
	     }
	 } else {
	     # 範囲内の場合
	     if($land->[$sx][$sy] == $kind) {
		 $count++;
	     }
	 }
    }
    return $count;
}

# 0から(n - 1)までの数字が一回づつ出てくる数列を作る
sub randomArray {
    my($n) = @_;
    my(@list, $i);

    # 初期値
    if($n == 0) {
	$n = 1;
    }
    @list = (0..$n-1);

    # シャッフル
    for ($i = $n; --$i; ) {
	my($j) = int(rand($i+1));
	if($i == $j) { next; };
	@list[$i,$j] = @list[$j,$i];
    }

    return @list;
}

# 名前変更失敗
sub tempChangeNothing {
    out(<<END);
${H2::tagBig_}名前、パスワードともに空欄です${H2::_tagBig}$H2::tempBack
END
}

# 名前変更資金足りず
sub tempChangeNoMoney {
    out(<<END);
${H2::tagBig_}資金不足のため変更できません${H2::_tagBig}$H2::tempBack
END
}

# 名前変更成功
sub tempChange {
    out(<<END);
${H2::tagBig_}変更完了しました${H2::_tagBig}$H2::tempBack
END
}

1;