Merge pull request '2026.5.1' (#18) from develop into main

Reviewed-on: #18

.gitignore

@@ -2,4 +2,5 @@
 /dist
 /memory.json
 /config/**
-!/config/example.yaml
+!/config/example.yaml
+/src/feature/earthquake/generateImage/data*.json

CHANGELOG.md

@@ -1,3 +1,26 @@
+# 2026.5.1
+- Feat: 地震の震度分布画像生成
+- Feat: 震度分布画に全タイルが埋まる機能
+- Feat: 震度分布画像の震源がタイル単位で中央になる機能
+- Feat: 震度分布画像で欠けているタイルが描画される機能
+- Feat: 震度分布画像のアセットの位置が中央基準になる機能
+- Chg: 全てのスケジュールが正確に動作するように
+- Chg: 毎日18:00に明日の天気予報を投稿するように
+- Chg: 震度分布画像のズームレベルを8から9へ
+- Chg: 震度分布画像の生成条件を震源と位置が存在するへ変更
+- Chg: 震度分布画像のアセットを並列に取得
+- Chg: 震度分布画像の震源のアセットに縁取りを追加
+- Chg: 震度分布画像の震度ではないアセットを拡大
+- Chg: ユーズの分割の案内文を太字に
+- Fix: 地震情報の画像生成での並び替えで、震度の位置が震源の位置として扱われる問題 
+- Fix: 毎日7:00に天気予報の返信をできない問題
+- Del: 最大震度が不明な場合に投稿するかどうかのconfigを削除
+
+# 2026.5.0
+- Feat(dev): 地震情報の画像生成機能は未完成のため、ユーズには適用されません
+- Chg: 地震情報でのタイトルを変更
+- Fix: 毎日7:00に天気予報が投稿されない問題
+
 # 2026.4.3
 - Chg: forループ内でlastReadを記録するように
 - Chg: lastReadを時刻ベースに

README.md

@@ -1,20 +1,21 @@
 # noticeUwuzu
 [uwuzu](https://www.uwuzu.com)向けのお知らせBotです。  
-uwuzu v1.6.3以上で利用可能です。
+uwuzu v1.6.7以上で利用可能です。
 
 ## 機能
-- 時報
+- 時報  
   毎時0分に「h:00になりました。」と投稿します。
-- 天気予報
-  [天気予報 API（livedoor 天気互換）](https://weather.tsukumijima.net/)を利用して、毎日7:00に天気予報を投稿します。
-- 地震情報
+- 天気予報  
+  [天気予報 API（livedoor 天気互換）](https://weather.tsukumijima.net/)を利用して、毎日7:00及び18:00に天気予報を投稿します。
+  18:00は明日の天気予報を投稿します。
+- 地震情報  
   [P2P地震情報](https://www.p2pquake.net/)のWebSocket APIを利用して、以下の情報を受信した際に投稿します。
   - 地震発生
   - 緊急地震速報（警報）
   - 津波予報
-- 新年迎春
+- 新年迎春  
   毎年1/1 0:00に投稿します。
-- デバッグモード
+- デバッグモード  
   設定で有効化することで、以下の機能が利用できます。  
   開発以外では使用しないでください。
   - NODE_TLS_REJECT_UNAUTHORIZED=1  

config/example.yaml

@@ -12,8 +12,6 @@ earthquake:
   # 例: 30を指定すると、最大震度が震度3以上の地震発生情報のみを投稿します。
   # 10(震度1), 20(震度2), 30(震度3), 40(震度4), 45(震度5弱), 50(震度5強), 55(震度6弱), 60(震度6強), 70(震度7)が有効です。
   requireMaxScale: 30
-  # 最大震度が不明な地震発生情報を投稿するかどうか boolean
-  canUnknownMaxScale: true
   # 過去のデバッグ用データを使用して地震情報を配信するかどうか boolean
   # デバッグ用途のみで使用してください。
   useHistoryData: false

locales/ja.yaml

@@ -9,7 +9,7 @@ weatherReply: |
   最低気温: {{ minTemp }}
   降水確率: {{ chanceOfRain }}
 earthquakeNotice: |
-  ### ==地震発生==
+  ### {{ type }}
   ⏰時刻: {{ occuredTime }}頃
   🫨最大震度: {{ maxScale }}
   📍震源地: {{ epicenter }}
@@ -26,14 +26,14 @@ tsunamiAreaMsg: |
   🌊第1波の状態: {{ condition }}
   🗼予想される津波の高さ: {{ maxHeight }}
 tsunamiForecastNotice: |
-  ### ==津波予報**発表**==
+  ### 津波予報**発表**
   ⏰発表時刻: {{ announceTime }}
 
   {{ areasMsg }}
 
   🔬情報源: P2P地震速報 - {{ source }}
 tsunamiCancelNotice: |
-  ### ==津波予報**解除**==
+  ### 津波予報**解除**
   ⏰発表時刻: {{ announceTime }}
   🔬情報源: P2P地震速報 - {{ source }}
 eewAreaMsg: |
@@ -42,7 +42,7 @@ eewAreaMsg: |
   ⏰到達予想時刻: {{ arrivalTime }}
   {{ kind }}
 eewNotice: |
-  ### ==***緊急地震速報（警報）***==
+  ### ***緊急地震速報（警報）***
   {{ isTest }}{{isAssume}}
   ⏰発表時刻: {{ announceTime }}
   ⏰地震発生時刻: {{ occuredTime }}
@@ -53,7 +53,7 @@ eewNotice: |
 
   🔬情報源: P2P地震速報
 eewCancelNotice: |
-  ### ==緊急地震速報（警報）**解除**==
+  ### 緊急地震速報（警報）**解除**
   {{ isTest }}
   ⏰発表時刻: {{ announceTime }}
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "notice-uwuzu",
-  "version": "2026.4.3",
+  "version": "2026.5.1",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {
@@ -17,12 +17,14 @@
     "@types/node": "^25.5.2",
     "@types/ws": "^8.18.1",
     "better-uwuzu-sdk": "git+https://gitea.last2014.com/last2014/better-uwuzu-sdk.git#1.1.7",
+    "cron-parser": "^5.5.0",
     "date-fns": "^4.1.0",
     "fs": "0.0.1-security",
     "i18next": "^26.0.3",
     "miq": "git+https://gitea.last2014.com/last2014/miq.git#1.0.1",
     "node-cron": "^4.2.1",
     "os": "^0.1.2",
+    "sharp": "^0.34.5",
     "tsc-alias": "^1.8.16",
     "typescript": "^5.9.3",
     "util": "^0.12.5",

pnpm-lock.yaml

@@ -17,6 +17,9 @@ importers:
       better-uwuzu-sdk:
         specifier: git+https://gitea.last2014.com/last2014/better-uwuzu-sdk.git#1.1.7
         version: git+https://gitea.last2014.com/last2014/better-uwuzu-sdk.git#8017146b1a2d6264d051b54afccdd46571b5fd00
+      cron-parser:
+        specifier: ^5.5.0
+        version: 5.5.0
       date-fns:
         specifier: ^4.1.0
         version: 4.1.0
@@ -33,6 +36,9 @@ importers:
         specifier: ^4.2.1
         version: 4.2.1
       os: {specifier: ^0.1.2, version: 0.1.2}
+      sharp:
+        specifier: ^0.34.5
+        version: 0.34.5
       tsc-alias:
         specifier: ^1.8.16
         version: 1.8.16
@@ -295,6 +301,10 @@ packages:
     resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==}
     engines: {node: ^12.20.0 || >=14}
 
+  cron-parser@5.5.0:
+    resolution: {integrity: sha512-oML4lKUXxizYswqmxuOCpgFS8BNUJpIu6k/2HVHyaL8Ynnf3wdf9tkns0yRdJLSIjkJ+b0DXHMZEHGpMwjnPww==}
+    engines: {node: '>=18'}
+
   date-fns@4.1.0:
     resolution: {integrity: sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==}
 
@@ -472,6 +482,10 @@ packages:
     resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
     engines: {node: '>= 0.4'}
 
+  luxon@3.7.2:
+    resolution: {integrity: sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==}
+    engines: {node: '>=12'}
+
   math-intrinsics@1.1.0:
     resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
     engines: {node: '>= 0.4'}
@@ -879,6 +893,10 @@ snapshots:
 
   commander@9.5.0: {}
 
+  cron-parser@5.5.0:
+    dependencies:
+      luxon: 3.7.2
+
   date-fns@4.1.0: {}
 
   decompress-response@6.0.0:
@@ -1055,6 +1073,8 @@ snapshots:
     dependencies:
       which-typed-array: 1.1.20
 
+  luxon@3.7.2: {}
+
   math-intrinsics@1.1.0: {}
 
   merge2@1.4.1: {}

pnpm-workspace.yaml

@@ -1,6 +1,4 @@
 onlyBuiltDependencies:
   - "better-uwuzu-sdk"
-  - canvas
-  - esbuild
   - "miq"
   - sharp

src/feature/command/index.ts

@@ -9,8 +9,13 @@ import unfollowCommand from "@/feature/command/unfollow";
 import miqCommand from "@/feature/command/miq";
 import initI18n from "@/lib/i18n";
 import config from "@/lib/config";
+import CronExpressionParser from "cron-parser";
 
 await initI18n();
+
+const next = BigInt(CronExpressionParser.parse(`*/${config.command.interval} * * * *`).next().getTime() * 1_000_000);
+while (process.hrtime.bigint() > next) {}
+
 console.log("コマンドの処理を行います");
 
 try {

src/feature/earthquake/generateImage/index.ts

@@ -0,0 +1,529 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import sharp from "sharp";
+
+/**
+ * 経度からX方向の座標情報を計算します
+ *
+ * 指定された経度とズームレベルに基づき、以下の4つの値を返します：
+ * - 世界座標系でのX（0〜1の範囲、グリニッジ子午線が0）
+ * - ズームレベルを考慮したピクセル単位のグローバルX座標
+ * - タイルグリッドにおけるX方向のタイル番号（tileNumberX）
+ * - タイル内（256×256ピクセル）でのX方向ピクセル位置（tileInnerX）
+ * @param lat - 経度
+ * @param z - ズームレベル（0以上の整数）
+ * @returns {{
+ *   worldCoordX: number, // 世界座標(0～1, グリニッジ子午線が原点(0))
+ *   globalPixelX: number, // ズームレベルを考慮したピクセル単位のY座標
+ *   tileNumberX: number, // 該当するタイル番号（0オリジン）
+ *   tileInnerX: number, // タイル内のピクセルY座標（0〜255）
+ * }}
+ * @copyright murasuke on Qiita - https://qiita.com/murasuke/items/ad81b7b726a3463fa3fe#%E7%B5%8C%E5%BA%A6
+ */
+function calcLngToTileX(lng: number, z: number) {
+  // 経度(-180〜180)を世界座標系のX(0〜1)に変換
+  const worldCoordX = (lng + 180) / 360;
+
+  // ズームレベル0(256×256px)の座標の位置を計算
+  let globalPixelX = worldCoordX * 256;
+
+  // ズームレベル(2^z)を考慮した座標を計算
+  globalPixelX = globalPixelX * Math.pow(2, z);
+
+  // 1つの画像タイルが256pxなので、256で割って左端からのタイルの枚数(位置)を求める
+  const tileNumberX = Math.floor(globalPixelX / 256);
+
+  // 該当タイル内のピクセル位置を算出する(タイル幅合計を引いた余り)
+  const tileInnerX = Math.floor(globalPixelX - tileNumberX * 256);
+
+  // 計算した値を返す
+  return {
+    worldCoordX, // 世界座標(0～1, グリニッジ子午線が原点(0))
+    globalPixelX, // ズームレベルを考慮したピクセル単位のY座標
+    tileNumberX, // 該当するタイル番号（0オリジン）
+    tileInnerX, // タイル内のピクセルY座標（0〜255）
+  };
+}
+
+/**
+ * 緯度からWebメルカトル投影によるY方向の座標情報を計算します。
+ *
+ * 指定された緯度とズームレベルに基づき、以下の4つの値を返します：
+ * - 世界座標系でのY（0〜1の範囲、北極が0）
+ * - ズームレベルを考慮したピクセル単位のグローバルY座標
+ * - タイルグリッドにおけるY方向のタイル番号（tileNumberY）
+ * - タイル内（256×256ピクセル）でのY方向ピクセル位置（tileInnerY）
+ *
+ * メルカトル図法で緯度から位置を算出する式 (https://qiita.com/Seo-4d696b75/items/aa6adfbfba404fcd65aa)
+ *  R ln(tan(π/4 + ϕ/2))
+ *    R: 半径
+ *    ϕ: 緯度(ラジアン)
+ * @param lat - 緯度（-85〜+85度の範囲が推奨）
+ * @param z - ズームレベル（0以上の整数）
+ * @returns {{
+ *   worldCoordY: number,    // 世界座標系Y（0〜1）
+ *   globalPixelY: number,   // ズームレベルを考慮したピクセル単位のY座標
+ *   tileNumberY: number,    // Y方向のタイル番号（0オリジン）
+ *   tileInnerY: number      // タイル内のピクセルY座標（0〜255）
+ * }}
+ * @copyright murasuke on Qiita - https://qiita.com/murasuke/items/ad81b7b726a3463fa3fe#%E7%B7%AF%E5%BA%A6
+ */
+function calcLatToTileY(lat: number, z: number) {
+  // 緯度からメルカトル図法の座標に変換して、世界座標系のY(0～1)を計算
+  let worldCoordY = latToWorldY(lat);
+
+  // ズームレベル0(256×256px)の座標の位置を計算
+  let globalPixelY = worldCoordY * 256;
+
+  // ズームレベル(2^z)を考慮した座標を計算
+  globalPixelY = globalPixelY * Math.pow(2, z);
+
+  // 1つの画像タイルが256pxなので、256で割って上端からのタイルの枚数(位置)を求める
+  const tileNumberY = Math.floor(globalPixelY / 256);
+
+  // 該当タイル内のピクセル位置を算出する(タイル幅合計を引いた余り)
+  const tileInnerY = Math.floor(globalPixelY - tileNumberY * 256);
+
+  // 計算した値を返す
+  return {
+    worldCoordY, // 世界座標(0～1, 北極側が原点(0))
+    globalPixelY, // ズームレベルを考慮したピクセル単位のY座標
+    tileNumberY, // 該当するタイル番号（0オリジン）
+    tileInnerY, // タイル内のピクセルY座標（0〜255）
+  };
+}
+
+/**
+ * メルカトル図法で投影した位置を元に世界座標系でのY(0〜1、北極が0)を計算する
+ *
+ * メルカトル図法の式（半径1の球体を想定）
+ *   ϕ = (π / 180) * 緯度
+ *   y = ln(tan(π/4 + ϕ/2))
+ *   ϕ:緯度(ラジアン)
+ *   y:投影した位置
+ *
+ * * 赤道を中心(0)にして、約-85〜+85度の範囲で-π～πの値になる
+ * * 高緯度では値が急増し無限大になる
+ * * y = ln((tan(ϕ) + 1) / cos(ϕ)) という式もある(同じ値になる)
+ *
+ * 地図で位置を計算するため、北極側が原点(0)で南極側が1となるように正規化した値を返す
+ *
+ * @param lat 緯度(-85～85)
+ * @returns {number} 世界座標系でのY（0〜1、北極が0）
+ * @copyright murasuke on Qiita - https://qiita.com/murasuke/items/ad81b7b726a3463fa3fe#%E7%B7%AF%E5%BA%A6
+ */
+function latToWorldY(lat: number) {
+  // 経度をラジアンに変換
+  const latRad = (Math.PI / 180) * lat;
+  // 緯度からメルカトル図法の座標に変換する
+  const mercatorY = Math.log(Math.tan(Math.PI / 4 + latRad / 2));
+
+  // -1～1 の範囲になるように調整(-85度～85度の範囲)
+  let worldCoordY = mercatorY / Math.PI;
+
+  // 原点(0)を赤道から、北極へ変換(0～1)
+  worldCoordY = 1 - (worldCoordY + 1) / 2;
+
+  return worldCoordY;
+}
+
+function getEdge<T extends any[]>(arr: T, property: keyof T[number]) {
+  if (arr.length === 0) {
+    return {
+      most: undefined,
+      least: undefined,
+    }
+  }
+
+  const counts = new Map<any, number>();
+  for (const item of arr) {
+    const val = item[property];
+    counts.set(val, (counts.get(val) || 0) + 1);
+  }
+
+  const uniqueValues = Array.from(counts.keys());
+  
+  const minVal = uniqueValues.reduce((a, b) => (a < b ? a : b));
+  const maxVal = uniqueValues.reduce((a, b) => (a > b ? a : b));
+
+  return {
+    most: maxVal,
+    least: minVal,
+  }
+}
+
+export default async function generateImage(message: any) {
+  if (
+    message.earthquake.hypocenter === undefined ||
+    message.points === undefined
+  )
+    return "input_lack";
+
+  const ZOOM_LEVEL = 9;
+  
+  // タイル・地点取得
+  const tiles: {
+    tileX: number;
+    tileY: number;
+  }[] = [];
+
+  const positions: ({
+    tileIndex: number;
+    innerX: number;
+    innerY: number;
+  } & ({
+    type: "epicenter";
+  } | {
+    type: "point";
+    scale: number;
+  }))[] = [];
+
+  if (
+    message.earthquake.hypocenter?.latitude !== undefined &&
+    message.earthquake.hypocenter?.latitude !== -200 &&
+    message.earthquake.hypocenter?.longitude !== undefined &&
+    message.earthquake.hypocenter?.longitude !== -200
+  ) {
+    // 震源地
+    const lng = message.earthquake.hypocenter.longitude;
+    const lat = message.earthquake.hypocenter.latitude;
+    const xData = calcLngToTileX(lng, ZOOM_LEVEL);
+    const yData = calcLatToTileY(lat, ZOOM_LEVEL);
+
+    tiles.push({
+      tileX: xData.tileNumberX,
+      tileY: yData.tileNumberY,
+    });
+
+    positions.push({
+      tileIndex: 0,
+      innerX: xData.tileInnerX,
+      innerY: yData.tileInnerY,
+      type: "epicenter",
+    });
+  }
+
+  if (
+    Array.isArray(message.points) &&
+    message.points.length > 0
+  ) {
+    // 観測点・区域
+    const areas = JSON.parse(readFileSync(`${import.meta.dirname}/areas.json`, "utf-8"));
+    const points = JSON.parse(readFileSync(`${import.meta.dirname}/points.json`, "utf-8"));
+    message.points.forEach((point: any) => {
+      let areaData: {
+        longitude: number;
+        latitude: number;
+      }
+
+      if (point.isArea) {
+        areaData = areas[point.addr];
+      } else {
+        areaData = points[point.addr];
+      }
+
+      const lng = areaData.longitude;
+      const lat = areaData.latitude;
+      const xData = calcLngToTileX(lng, ZOOM_LEVEL);
+      const yData = calcLatToTileY(lat, ZOOM_LEVEL);
+      
+      const tilePosition = {
+        tileX: xData.tileNumberX,
+        tileY: yData.tileNumberY,
+      }
+
+      let tileIndex: number;
+
+      const sameTile = tiles
+        .map((value, index) => ({ value, index }))
+        .filter(tile => JSON.stringify(tile.value) === JSON.stringify(tilePosition))[0];
+
+      if (sameTile) {
+        tileIndex = sameTile.index;
+      } else {
+        tiles.push(tilePosition);
+        tileIndex = tiles.length - 1;
+      }
+
+      if (tiles.filter(tile => JSON.stringify(tile) === JSON.stringify(tilePosition)).length === 0) {
+        tiles.push(tilePosition);
+      }
+
+      positions.push({
+        tileIndex,
+        innerX: xData.tileInnerX,
+        innerY: yData.tileInnerY,
+        type: "point",
+        scale: point.scale,
+      });
+    });
+  }
+
+  // 画像生成
+  const WIDTH = 1920;
+  const HEIGHT = 1080;
+
+  let result = sharp({
+    create: {
+      width: WIDTH,
+      height: HEIGHT,
+      channels: 4,
+      background: "#ffffff",
+    }
+  });
+
+  let compounds: (sharp.OverlayOptions & ({
+    type: "tile" | "epicenter" | "other";
+  } | {
+    type: "scale";
+    scale: number;
+  }))[] = [];
+
+  // タイルの幅、最大最小
+  let tileXCount = getEdge(tiles, "tileX");
+  let tileYCount = getEdge(tiles, "tileY");
+  let xSize = tileXCount.most - tileXCount.least + 1;
+  let ySize = tileYCount.most - tileYCount.least + 1;
+
+  // タイルサイズ仮計算
+  let tileSize: number;
+
+  xSize = tileXCount.most - tileXCount.least + 1;
+  ySize = tileYCount.most - tileYCount.least + 1;
+
+  if (xSize > ySize) {
+    tileSize = Math.round(WIDTH / xSize);
+  } else {
+    tileSize = Math.round(HEIGHT / ySize);
+  }
+
+  // 全画面
+  if (WIDTH - xSize * tileSize > 10) {
+    const requireTilesX = Math.ceil(WIDTH / tileSize);
+    const halfTilesX = Math.ceil(requireTilesX / 2);
+
+    tileXCount = {
+      least: tileXCount.least - halfTilesX,
+      most: tileXCount.most + halfTilesX,
+    }
+  }
+
+  if (HEIGHT - ySize * tileSize > 10) {
+    const requireTilesY = Math.ceil(HEIGHT / tileSize);
+    const halfTilesY = Math.ceil(requireTilesY / 2);
+
+    tileYCount = {
+      least: tileYCount.least - halfTilesY,
+      most: tileYCount.most + halfTilesY,
+    }
+  }
+
+  // 震源を中心とする
+  const epicenterPosition = positions.filter(position => position.type === "epicenter")[0];
+  if (!epicenterPosition)
+    return "input_lack";
+
+  const epicenterTile = tiles[epicenterPosition.tileIndex];
+  if (!epicenterTile)
+    return "input_lack";
+
+  const leftPx = (epicenterTile.tileX - tileXCount.least) * tileSize + epicenterPosition.innerX;
+  const rightPx = xSize * tileSize - leftPx;
+  const topPx = (epicenterTile.tileY - tileYCount.least) * tileSize + epicenterPosition.innerY;
+  const bottomPx = ySize * tileSize - topPx;
+
+  if (leftPx > rightPx) {
+    const leftTiles = epicenterTile.tileX - tileXCount.least;
+    tileXCount = {
+      ...tileXCount,
+      most: epicenterTile.tileX + leftTiles,
+    }
+  } else {
+    const rightTiles = tileXCount.most - epicenterTile.tileX;
+    tileXCount = {
+      ...tileXCount,
+      least: epicenterTile.tileX - rightTiles,
+    }
+  }
+
+  if (topPx > bottomPx) {
+    const topTiles = epicenterTile.tileY - tileYCount.least;
+    tileYCount = {
+      ...tileYCount,
+      most: epicenterTile.tileY + topTiles,
+    }
+  } else {
+    const bottomTiles = tileYCount.most - epicenterTile.tileY;
+    tileYCount = {
+      ...tileYCount,
+      least: epicenterTile.tileY - bottomTiles,
+    }
+  }
+
+  // タイルサイズ再計算
+  xSize = tileXCount.most - tileXCount.least + 1;
+  ySize = tileYCount.most - tileYCount.least + 1;
+
+  if (xSize > ySize) {
+    tileSize = Math.round(WIDTH / xSize);
+  } else {
+    tileSize = Math.round(HEIGHT / ySize);
+  }
+
+  // 欠けているタイルを取得
+  for (let xIndex = 0; xIndex < xSize; xIndex++) {
+    const itX = xIndex + tileXCount.least;
+    
+    for (let yIndex = 0; yIndex < ySize; yIndex++) {
+      const itY = yIndex + tileYCount.least;
+
+      const itTile = tiles.filter(tile => tile.tileX === itX && tile.tileY === itY)[0];
+      if (itTile)
+        continue;
+
+      tiles.push({
+        tileX: itX,
+        tileY: itY,
+      });
+    }
+  }
+
+  // アセット
+  const assets: Record<string, {
+    buffer: Buffer<ArrayBuffer>;
+    size: number;
+  }> = {}
+  const assetsList = [
+    "scales/10",
+    "scales/20",
+    "scales/30",
+    "scales/40",
+    "scales/45",
+    "scales/46",
+    "scales/50",
+    "scales/55",
+    "scales/60",
+    "scales/70",
+    "epicenter",
+  ];
+
+  await Promise.all(assetsList.map(async name => {
+    const key = name.split("/").at(-1);
+    if (!key)
+      return;
+
+    const asset = readFileSync(`${import.meta.dirname}/assets/${name}.png`);
+    const assetMeta = await sharp(asset).metadata();
+    const assetSize = assetMeta.width;
+
+    assets[key] = {
+      buffer: asset,
+      size: assetSize,
+    }
+  }));
+
+  // 各画像処理
+  await Promise.all(tiles.map(async (tile, index) => {
+    const TYPE = "blank";
+    const BASE_URL = "https://cyberjapandata.gsi.go.jp/xyz";
+
+    const request = await fetch(`${BASE_URL}/${TYPE}/${ZOOM_LEVEL}/${tile.tileX}/${tile.tileY}.png`);
+
+    if (!request.ok)
+      return;
+
+    const tileImg = await sharp(await request.arrayBuffer()).resize({
+      width: tileSize,
+      height: tileSize,
+    }).png().toBuffer();
+
+    const top = tileSize * (tile.tileY - tileYCount.least);
+    const left = tileSize * (tile.tileX - tileXCount.least);
+
+    compounds.push({
+      type: "tile",
+      input: tileImg,
+      top,
+      left,
+    });
+
+    const itTilePositions = positions.filter(position => position.tileIndex === index);
+    itTilePositions.forEach(position => {
+      const requireAssetName = position.type === "epicenter"
+        ? "epicenter"
+        : String(position.scale);
+
+      const asset = assets[requireAssetName];
+      if (!asset)
+        return;
+
+      const tileResizedSize = tileSize / 256;
+
+      let about: any;
+
+      if (position.type === "epicenter") {
+        about = {
+          type: "epicenter",
+        }
+      } else {
+        about = {
+          type: "scale",
+          scale: position.scale,
+        }
+      }
+
+      compounds.push({
+        ...about,
+        input: asset.buffer,
+        top: Math.round(top + position.innerY * tileResizedSize - asset.size / 2),
+        left: Math.round(left + position.innerX * tileResizedSize - asset.size / 2),
+      });
+    });
+  }));
+
+  // compounds並び替え
+  const TYPE_PRIORITY: Record<string, number> = {
+    tile: 1,
+    scale: 2,
+    epicenter: 3,
+  }
+
+  compounds = [...compounds].sort((a, b) => {
+    if (TYPE_PRIORITY[a.type] !== TYPE_PRIORITY[b.type]) {
+      return (TYPE_PRIORITY[a.type] ?? 99) - (TYPE_PRIORITY[b.type] ?? 99);
+    }
+
+    if (a.type === "scale" && b.type === "scale") {
+      return a.scale - b.scale;
+    }
+
+    return 0;
+  });
+
+  // 案内部分
+  const informationPath = `${import.meta.dirname}/assets/information.png`;
+  const informationBuffer = readFileSync(informationPath);
+  const informationMeta = await sharp(informationPath).metadata();
+  const informationMargin = 20;
+  compounds.push({
+    type: "other",
+    input: informationBuffer,
+    top: HEIGHT - informationMeta.height - informationMargin,
+    left: WIDTH - informationMeta.width - informationMargin,
+  });
+
+  // クレジット部分
+  const creditPath = `${import.meta.dirname}/assets/credit.png`;
+  const creditBuffer = readFileSync(creditPath);
+  const creditMeta = await sharp(creditPath).metadata();
+  compounds.push({
+    type: "other",
+    input: creditBuffer,
+    top: HEIGHT - creditMeta.height,
+    left: 0,
+  });
+
+  result.composite(compounds);
+
+  const buffer = await result.png().toBuffer();
+  return buffer;
+}

src/feature/earthquake/index.ts

@@ -7,6 +7,7 @@ import i18next from "i18next";
 import { readFileSync } from "node:fs";
 import { EOL } from "node:os";
 import { WebSocket } from "ws";
+import generateImage from "@/feature/earthquake/generateImage";
 
 await initI18n();
 
@@ -88,7 +89,7 @@ const processMessage = async (message: any) => {
       "30": "震度3",
       "40": "震度4",
       "45": "震度5弱",
-      "46": "**推定**震度5弱以上***(正確には不明)***",
+      "46": "**推定**震度5弱以上***(不明)***",
       "50": "震度5強",
       "55": "震度6弱",
       "60": "震度6強",
@@ -104,15 +105,6 @@ const processMessage = async (message: any) => {
         {
           console.log("地震発生情報を受信しました");
 
-          if (
-            (message.earthquake.maxScale === -1 ||
-            message.earthquake.maxScale === undefined) &&
-            !config.earthquake.canUnknownMaxScale
-          ) {
-            console.log("最大震度が不明であり、最大震度が不明な場合の投稿が許可されていないため、スキップします");
-            break;
-          }
-
           if (
             message.earthquake.maxScale !== -1 &&
             message.earthquake.maxScale < config.earthquake.requireMaxScale
@@ -121,6 +113,11 @@ const processMessage = async (message: any) => {
             break;
           }
 
+          const typeMessage: Record<string, string> = {
+            "ScalePrompt": "震度速報",
+            "Destination": "震源情報",
+          }
+
           const domesticTsunamiMessages: Record<string, string> = {
             "None": "😌この地震による**国内**の津波の心配はありません。",
             "Unknown": "😕この地震による**国内**の***津波情報は***不明です。",
@@ -172,32 +169,61 @@ const processMessage = async (message: any) => {
             .join(EOL.repeat(2))
             .trim();
 
-          await createUeuse({
-            text: i18next.t("earthquakeNotice", {
-              occuredTime: format(new Date(message.earthquake.time), "yyyy年M月d日 H:mm"),
-              maxScale: scaleMessages[String(message.earthquake.maxScale)],
-              epicenter: message.earthquake.hypocenter.name === ""
-                ? "不明"
-                : message.earthquake.hypocenter.name,
-              magnitude: message.earthquake.hypocenter.magnitude === -1
-                ? "不明"
-                : `M${message.earthquake.hypocenter.magnitude.toFixed(1)}`,
-              depth: message.earthquake.hypocenter.depth === 0
-                ? "ごく浅い"
-                : (message.earthquake.hypocenter.depth === -1
-                  ? "不明"
-                  : `${message.earthquake.hypocenter.depth}km`),
-              domesticTsunami: domesticTsunamiMessages[(message.earthquake.domesticTsunami ?? "Unknown")],
-              foreignTsunami: foreignTsunamiMessages[(message.earthquake.foreignTsunami ?? "Unknown")],
-              points: pointsMsg === ""
-                ? ""
-                : EOL.repeat(2) + pointsMsg,
-              source: message.issue.source ?? "不明",
-              comment: message.comments.freeFormComment === ""
-                ? ""
-                : EOL + message.comments.freeFormComment + EOL,
-            }),
-          }, "地震発生情報");
+          let earthquakeUniqid: string | null = null;
+
+          await Promise.allSettled([
+            (async () => {
+              const ueuses = await createUeuse({
+                text: i18next.t("earthquakeNotice", {
+                  type: typeMessage[message.issue.type] ?? "地震情報",
+                  occuredTime: format(new Date(message.earthquake.time), "yyyy年M月d日 H:mm"),
+                  maxScale: scaleMessages[String(message.earthquake.maxScale)],
+                  epicenter: message.earthquake.hypocenter.name === ""
+                    ? "不明"
+                    : message.earthquake.hypocenter.name,
+                  magnitude: message.earthquake.hypocenter.magnitude === -1
+                    ? "不明"
+                    : `M${message.earthquake.hypocenter.magnitude.toFixed(1)}`,
+                  depth: message.earthquake.hypocenter.depth === 0
+                    ? "ごく浅い"
+                    : (message.earthquake.hypocenter.depth === -1
+                      ? "不明"
+                      : `${message.earthquake.hypocenter.depth}km`),
+                  domesticTsunami: domesticTsunamiMessages[(message.earthquake.domesticTsunami ?? "Unknown")],
+                  foreignTsunami: foreignTsunamiMessages[(message.earthquake.foreignTsunami ?? "Unknown")],
+                  points: pointsMsg === ""
+                    ? ""
+                    : EOL.repeat(2) + pointsMsg,
+                  source: message.issue.source ?? "不明",
+                  comment: message.comments.freeFormComment === ""
+                    ? ""
+                    : EOL + message.comments.freeFormComment + EOL,
+                }),
+              }, "地震発生情報");
+
+              earthquakeUniqid = ueuses[0]?.uniqid ?? null;
+            })(),
+            (async () => {
+              const result = await generateImage(message);
+
+              if (typeof result === "string") {
+                console.warn("情報が不足しているため、地震の画像生成ができませんでした");
+                return;
+              }
+
+              while (typeof (earthquakeUniqid as string | null) !== "string") {}
+
+              await createUeuse({
+                text: "この地震の震度分布画像を生成しました。",
+                media: {
+                  photo: [
+                    result.toString("base64"),
+                  ]
+                },
+                reuseid: (earthquakeUniqid as unknown as string),
+              }, "震度分布画像");
+            })(),
+          ]);
         }
         break;
       case 552:

src/feature/hnyNotice.ts

@@ -1,25 +1,26 @@
 import { createUeuse } from "@/lib/client";
 import initI18n from "@/lib/i18n";
+import CronExpressionParser from "cron-parser";
 import { format } from "date-fns";
 import i18next from "i18next";
-import { parentPort } from "node:worker_threads";
 
 await initI18n();
 
-parentPort?.on("message", async () => {
-  console.log("新年迎春の投稿を行います");
+const next = BigInt(CronExpressionParser.parse("0 0 1 1 *").next().getTime() * 1_000_000);
+while (process.hrtime.bigint() > next) {}
 
-  try {
-    await createUeuse({
-      text: i18next.t("hnyNotice", { year: String(new Date().getFullYear()) }),
-    }, "新年迎春");
+console.log("新年迎春の投稿を行います");
 
-    console.log("新年迎春投稿時刻:", format(new Date(), "yyyy/M/d H:mm:ss:SSS"));
-    process.exit(0);
-  } catch (err: any) {
-    console.error("message" in err
-      ? err.message
-      : err);
-    process.exit(1);
-  }
-});
+try {
+  await createUeuse({
+    text: i18next.t("hnyNotice", { year: String(new Date().getFullYear()) }),
+  }, "新年迎春");
+
+  console.log("新年迎春投稿時刻:", format(new Date(), "yyyy/M/d H:mm:ss:SSS"));
+  process.exit(0);
+} catch (err: any) {
+  console.error("message" in err
+    ? err.message
+    : err);
+  process.exit(1);
+}

src/feature/timeNotice.ts

@@ -1,9 +1,14 @@
 import { createUeuse } from "@/lib/client";
 import initI18n from "@/lib/i18n";
+import CronExpressionParser from "cron-parser";
 import { format } from "date-fns";
 import i18next from "i18next";
 
 await initI18n();
+
+const next = BigInt(CronExpressionParser.parse("0 * * * *").next().getTime() * 1_000_000);
+while (process.hrtime.bigint() > next) {}
+
 console.log("時報の投稿を行います");
 
 try {

src/feature/weatherNotice.ts

@@ -2,6 +2,7 @@ import client from "@/lib/client";
 import config from "@/lib/config";
 import initI18n from "@/lib/i18n";
 import Memory from "@/lib/memory";
+import CronExpressionParser from "cron-parser";
 import i18next from "i18next";
 import { readFileSync } from "node:fs";
 import { EOL } from "node:os";
@@ -57,8 +58,19 @@ const cityList = [
   "471010",
 ];
 
-if (!isMainThread && workerData === "scheduledWeatherNotice") {
+if (
+  !isMainThread &&
+  typeof workerData === "string" &&
+  workerData.startsWith("scheduledWeatherNotice")
+) {
   await initI18n();
+
+  const cronStr = workerData.endsWith("Tomorrow")
+    ? "0 18 * * *"
+    : "0 7 * * *"
+  const next = BigInt(CronExpressionParser.parse(cronStr).next().getTime() * 1_000_000);
+  while (process.hrtime.bigint() > next) {}
+
   console.log("天気予報の投稿を行います");
 
   try {
@@ -88,7 +100,7 @@ if (!isMainThread && workerData === "scheduledWeatherNotice") {
 
     console.log("天気仮投稿:", provisionalUeuse.uniqid);
 
-    weatherReply(provisionalUeuse.uniqid);
+    await weatherReply(provisionalUeuse.uniqid, workerData.endsWith("Tomorrow"));
     process.exit(0);
   } catch (err: any) {
     console.error("message" in err
@@ -98,7 +110,7 @@ if (!isMainThread && workerData === "scheduledWeatherNotice") {
   }
 }
 
-export async function weatherReply(uniqid: string) {
+export async function weatherReply(uniqid: string, isTomorrow: boolean) {
   // インデックス
   const aboutFullLength = 3100;
   const mem = Memory.memory;
@@ -137,21 +149,23 @@ export async function weatherReply(uniqid: string) {
       });
 
       const data = await res.json();
-      const today = data.forecasts[0];
+      const itDay = isTomorrow
+        ? data.forecasts[1]
+        : data.forecasts[0];
 
       // 天気
-      const weather = today.telop ?? "取得できませんでした";
-      const maxTemp = today.temperature.max.celsius
-        ? `${today.temperature.max.celsius}℃`
+      const weather = itDay.telop ?? "取得できませんでした";
+      const maxTemp = itDay.temperature.max.celsius
+        ? `${itDay.temperature.max.celsius}℃`
         : "取得できませんでした";
-      const minTemp = today.temperature.min.celsius
-        ? `${today.temperature.min.celsius}℃`
+      const minTemp = itDay.temperature.min.celsius
+        ? `${itDay.temperature.min.celsius}℃`
         : "取得できませんでした";
       const chanceOfRain = (
-          today.chanceOfRain.T06_12 !== null &&
-          today.chanceOfRain.T06_12 !== "--%"
+          itDay.chanceOfRain.T06_12 !== null &&
+          itDay.chanceOfRain.T06_12 !== "--%"
         )
-        ? today.chanceOfRain.T06_12
+        ? itDay.chanceOfRain.T06_12
         : "取得できませんでした";
 
       weatherResults[chunkIndex] += `${i18next.t("weatherReply", {

src/index.ts

@@ -20,7 +20,7 @@ try {
 
   await initData();
 
-  new Worker(`${import.meta.dirname}/feature/earthquakeNotice.js`);
+  new Worker(`${import.meta.dirname}/feature/earthquake/index.js`);
 
   console.log("Botが起動しました");
 } catch (err: any) {
@@ -31,26 +31,34 @@ try {
 }
 
 try {
-  schedule("0 * * * *", async () => {
+  schedule("56 59 * * * *", async () => {
     new Worker(`${import.meta.dirname}/feature/timeNotice.js`);
   });
 
-  schedule("0 7 * * *", async () => {
-    new Worker(`${import.meta.dirname}/feature/weatherNotice.js`);
+  schedule("56 59 6 * * *", async () => {
+    new Worker(`${import.meta.dirname}/feature/weatherNotice.js`, {
+      workerData: "scheduledWeatherNotice",
+    });
   });
 
-  schedule(`*/${config.command.interval} * * * *`, async () => {
+  schedule("56 59 17 * * *", async () => {
+    new Worker(`${import.meta.dirname}/feature/weatherNotice.js`, {
+      workerData: "scheduledWeatherNoticeTomorrow",
+    });
+  });
+
+  const interval = config.command.interval;
+  const targetMinutes = [];
+  for (let i = interval - 1; i < 60; i += interval) {
+    targetMinutes.push(i);
+  }
+  const minutesStr = targetMinutes.join(",");
+  schedule(`56 ${minutesStr} * * * *`, async () => {
     new Worker(`${import.meta.dirname}/feature/command/index.js`);
   });
-
-  let hnyWorker: Worker | undefined = undefined;
-
-  schedule("57 59 23 31 12 *", () => {
-    hnyWorker = new Worker(`${import.meta.dirname}/feature/hnyNotice.js`);
-  });
-
-  schedule("0 0 0 1 1 *", () => {
-    hnyWorker?.postMessage("");
+  
+  schedule("56 59 23 31 12 *", () => {
+    new Worker(`${import.meta.dirname}/feature/hnyNotice.js`);
   });
 } catch (err: any) {
   console.error("message" in err

src/lib/client.ts

@@ -15,12 +15,15 @@ export default client;
 
 export const createUeuse = async (data: ApiMap["ueuse/create"]["body"], title: string) => {
   const mem = Memory.memory;
-  const excessedMessage = "👉返信に続きがあります。";
+  const excessedMessage = "**👉返信に続きがあります。**";
   
   let lines = data.text.split(EOL);
   let firstUniqid = "";
   let count = 0;
 
+  type ExtractSuccess<T> = T extends { success: true } ? T : never;
+  const results: ExtractSuccess<ApiMap["ueuse/create"]["response"]>[] = [];
+
   while (lines.length > 0) {
     count++;
     let currentText = "";
@@ -76,6 +79,7 @@ export const createUeuse = async (data: ApiMap["ueuse/create"]["body"], title: s
       if (response.success) {
         success = true;
         postedUniqid = response.uniqid;
+        results.push(response);
         break;
       }
 
@@ -99,4 +103,6 @@ export const createUeuse = async (data: ApiMap["ueuse/create"]["body"], title: s
       lines.shift();
     }
   }
+
+  return results;
 }

src/lib/config.ts

@@ -20,7 +20,6 @@ const schema = z.object({
       z.literal(60),
       z.literal(70),
     ]),
-    canUnknownMaxScale: z.boolean(),
     useHistoryData: z.boolean(),
     reconnectInterval: z.number().positive(),
   }),